A surface-level walkthrough of how we think about reasoning: our departure from pattern matching, our disillusionment with static knowledge representations, and our conviction that reasoning requires traversal. This doesn't touch on most of Core's components or architecture. Core is already available in closed beta and via API as its first human-language-friendly form.

You have never learned anything in isolation. When someone tells you Tim Cook runs Apple, you don't file away a flat fact. Your mind simultaneously recognises that Tim Cook is a person, Apple is an organisation, "runs" implies executive authority, this knowledge is temporally bound to the present, and it connects (laterally, hierarchically, causally) to things you already understand about technology, corporate governance, supply chains, maybe a product launch you read about last week. You inferred all of that unprompted. Nobody handed you a schema.

That process, forming structured, relational knowledge from raw information, is conceptual learning. Every new piece of knowledge understood in relation to everything else already known, or discarded as noise.

And none of this is limited to abstraction. Code is conceptual. Numerical data is conceptual. A price movement, a function signature, a sensor reading. Each carries meaning only in relation to other things. Conceptual learning draws no line between "soft" knowledge and "hard" data. If something has structure, relationships, and context, it's a concept, and conceptual learning treats it uniformly.

The Problem With Pattern Matching

 Most approaches to machine intelligence rest on statistical pattern matching. Systems ingest large volumes of data, identify correlations, and generate outputs weighted by probability. This works tolerably well when fluency or approximation is the objective. It degrades, often quietly, often catastrophically, when you need precision, consistency, or reasoning that can account for its own conclusions.

The limitation is architectural. A system built on statistical association has no internal model of what things are or how they structurally relate. It registers that certain patterns co-occur, with no understanding of why. Serviceable enough for text generation. Unreliable for decision-making, numerical reasoning, or adapting to new information without wholesale retraining.

The same architectural critique extends to conventional knowledge graphs. Traditional KGs rely on embedding lookups or pattern matching over flat triples (subject, predicate, object) stored as static assertions. Layering agentic retrieval on top doesn't fix what's broken underneath; it just adds orchestration complexity to a representation that was never meant for inference. Retrieval over flat triples scales into more retrieval, never into reasoning.

So: is there an approach that reasons where pattern matching, and lookup, can't?

A Different Starting Point

Conceptual learning starts from a different premise: a system should form actual representations of what things are and how they relate, not accumulate associations between surface-level patterns.

This means processing information across multiple dimensions simultaneously: temporally (sequencing events and states), causally (modelling what precipitated what), associatively (mapping connections across domains), and meta-cognitively (evaluating its own reasoning quality against what the task actually requires). None of this happens in sequence. Knowledge gets encoded this way from the instant it enters the architecture, concurrently, interdependently, because the human mind doesn't execute a "temporal module" followed by a "causal module" either. It understands things in context, all at once, and that's the capacity we set out to build around.

A system built on this foundation recognises that Tim Cook is a person and Apple is an organisation without explicit instruction. It infers the relationship autonomously, determines which elements of its knowledge carry the most weight in a given context, and distils what's most relevant. It generalises across domains and data types because its comprehension is structural, so it doesn't need labelled examples of each.

Core, our reasoning architecture, follows this premise. Human cognition remains the best example of general reasoning we have. We took that seriously as a source of architectural inspiration, not as a metaphor.

Reasoning As Traversal

 Learning and reasoning are conventionally treated as separate processes. Conceptual learning (how knowledge forms) and conceptual reasoning (what happens when you use it) are two sides of the same thing. It reasons by learning and learns by reasoning.

When you reason through a problem, you're navigating your own knowledge. You begin from what you know, follow relationships to adjacent ideas, and arrive at conclusions that were never explicitly stored but emerge from the path itself.

The mechanism is the same whether the path is short or long. If someone asks what colour the dog is, you start from "dog" and the answer is right there: one step, one relationship, trivial. You don't decompose the dog into molecules and work upward. You begin at the concept itself, at the right level of abstraction, and the distance to the answer maps to conceptual distance, not computational distance.

Now scale that. If someone asks how semiconductor export restrictions might affect consumer electronics pricing, you walk: semiconductors → fabrication → TSMC → Apple → supply constraints → component costs → retail pricing. Each step follows from the last, and the conclusion materialises from the walk. Same mechanism, longer path.

This is what makes traversal fundamentally different from retrieval. A conceptual reasoning system starts from meaning. Concepts are connected through meaningful, multi-dimensional relationships, and reasoning moves through those connections. The answer to a query is constructed in motion, whether that motion is one step or twenty, assembling itself the way your understanding of a complex situation builds as you think through it.

Contrast this with how knowledge graphs work. Traditional KGs store relationships as static triples and retrieve them through embedding similarity or pattern-matched queries: "what is near this vector?" or "what matches this template?" The representation is flat. Agentic retrieval layered on top doesn't change that; it just orchestrates faster lookups. Core's knowledge layer uses a representation much richer than triples, closer to hypergraphs than conventional KGs, as one component of a larger architecture. It reasons where they retrieve. The reasoning path is itself the computation, each step activating related concepts, weighting relevance dynamically, and propagating context forward.

The richer its knowledge becomes, the more nuanced its reasoning grows. A statistical model has no internal structure to deepen, only weights and probability distributions over outputs. A knowledge graph, however large, offers only lookup depth, never reasoning depth. Both hit the same ceiling. Core was designed around a different premise entirely, so the ceiling doesn't apply.

It can also reason about things it was never explicitly taught, provided the relevant concepts and relationships exist. Novel conclusions emerge from novel paths through existing knowledge.

None of this is an argument against large language models. Opinions differ on where the boundaries of statistical approaches lie, and we hold ours without dismissing what they do well. LLMs are genuinely good at language processing and encyclopedic knowledge. But we don't believe they will ever be the centrepiece for reasoning. Core aims to occupy that space, not to replace what's already good at something else.

Not Everything Needs To Be Learned

Here's what gets missed about human memory: you don't do verbatim recall for most of what you know. You understand things conceptually (causes, relationships, patterns, principles) and reconstruct specifics from that understanding when the moment demands it. You know roughly how the 2008 financial crisis unfolded, what precipitated it, what followed. You probably don't remember exact dates or precise figures unless they mattered enough to stick.

But certain things you do remember exactly. Your name. Your age. Your address. The PIN to your bank account. Different category entirely. Precise, identity-level facts that you simply know, always, without reasoning your way to them.

A system inspired by how cognition handles knowledge should respect that distinction. Certain foundational facts, what we call primordials, occupy their own tier. Exact, perpetually accessible, exempt from the fluid reasoning that conceptual knowledge undergoes. You don't need to "figure out" your own name. Some things are just known, and the architecture handles that category of knowledge the same way: fixed, immediate, not subject to reasoning.

Primordials are shaped by the user. You are the trainer. You determine what Core should treat as bedrock: the facts, identities, and constants that anchor everything else. This is deliberate. The same reasoning architecture applied to different domains needs different foundations, and only the person training it knows what should never drift.

And then there's everything else: raw historical data, documents, precise figures, verbatim records. Trying to internalise all of that into the reasoning architecture is like memorising every book you've ever read word for word. You wouldn't do that. It would destroy the thing that makes your cognition valuable: the capacity to think abstractly and relationally.

Instead, you treat books as instruments. You know they exist, you know roughly what's in them, and you reach for them when exactitude matters. External data sources serve the same role in a conceptual learning system: queryable instruments, available when precision is needed, without burdening the architecture that does the actual reasoning. Cramming verbatim storage into a reasoning system is exactly the wrong trade-off.

Where It Compounds

The approach compounds.

Every new concept that enters Core enriches it. More concepts yield more relationships to discover, more ways to reason, more emergent understanding. It grows more capable as it learns, not just larger. The same way human expertise compounds, where each new thing you learn improves your ability to learn the next because you have more structure to connect it to.

What doesn't get reinforced fades. Knowledge that stops being relevant loses weight over time, the same way you gradually forget what you don't use. Growth and decay are both part of the reasoning.

Metacognition, rendered computational. You reflect on your own thinking instinctively, notice when your reasoning feels unsound, adjust your approach. Any architecture that takes human cognition seriously as inspiration can't leave that capacity out.

And when signals conflict, Core maintains competing interpretations. It doesn't average them or default to the most probable answer. It holds ambiguity until one interpretation resolves with sufficient clarity, something no statistical operation produces, but reasoning naturally does. 

More Context

What's available in the closed beta is Core's first human-language-friendly form: the reasoning architecture running in a conversational interface and an OpenAI-compliant API, with much of its complexity and freedom deliberately stripped back for the sake of natural language interaction. The complete architecture, and the other forms it can take, will be discussed in future releases.

We hope you enjoy playing with it as beta opens and before we roll out the different forms Core can be interacted with. Thank you to all our closed beta users for the feedback so far. We'll be slowly exiting stealth on multiple aspects in the first half of this year.

For now, this is the entry point.