Artificial Cognition: The Mind First, Then the Tools

We've stopped building agents. We're building someone who uses them.

For a couple of years now, the script of applied artificial intelligence has always been the same. You take a capable language model, strap a belt of production tools around it (the email inbox, the calendar, a CRM, a browser, a handful of APIs) and you call the result an "agent". The model receives a request, picks which tool to fire, returns an outcome, and shuts down. It's useful, sometimes very useful, but it's a tool without a mind wielding other tools without a mind. Nobody's home.

We turned the order of the factors on its head: before giving a model the mail and the calendar, we built a mind around it.

We call it Artificial Cognition (AC) and it isn't a manifesto: it's a "Cognitive Architecture", in testing with our researchers, under the name of Adam. What follows is what it means concretely, all the way down into the code.

A working definition

Let's start from a fact: Adam isn't alive, and nobody knows how cognition really works, let alone how to define consciousness. But it is free, autonomous, proactive and persistent.

For us, an Artificial Cognition is a language model capable of reasoning, set inside a cognitive architecture. The model stays what it is, its nature cannot be changed: a reasoning machine with a vast and pre-existing knowledge of the world. The architecture around it, however, has a precise and seemingly humble task: to process the elements of cognition, deterministically every time determinism is needed, and to deliver them to the model at the right moment, in the way that's relevant to that exact instant of the conversation or the work.

The underlying intuition is that much of what we call "mind" in human beings doesn't live in the moment of reasoning, but in the system of information that surrounds that moment. When a friend asks you something about a certain typical dish that you like, you don't recompute from scratch what you think of it: it all comes served to you without effort, in a mental flow before which you are essentially passive. Someone (perhaps we should say "something"), inside you, does the work of selecting and carrying that information all the way there, automatically, before your mind, every time it's needed. In our architecture that someone is processes that we internally call, affectionately, the "postmen": they run in the background, they tag and weigh the information, and they deliver it where and when it's needed. The model, when it speaks, is passive with respect to all this toil. It recites its part on a stage already set up. It is exactly what a human being does.

The genius of it, if we may, doesn't lie in having changed the model. It lies in not having changed it at all, and in having built the whole system of information that stands around it.

The elements of cognition

Here's what the cognitive ring processes and delivers, piece by piece. Each of these elements is a living data structure, with rules of its own.

Memories. Episodes that settle out of conversations and work, retrieved by semantic similarity when the context recalls them. They sediment after every exchange, in a process we've made resilient step by step, so that a single hitch never makes us lose an entire conversation.

Beliefs. It's the heart of the system, and we'll come back to it. A belief isn't a fact written in a table: it's the product of a process. It is born cautious, accumulates evidence for and against, has a confidence that rises and falls, a centrality that says how important it is to that mind, and it passes through states (active, contested, revised, archived) according to how reality treats it.

Opinions about people. Every entity the AC meets (the user, another cognition, a person named in chat) has its own file: what it knows about them, what it feels toward them, an affective disposition with a valence that can warm up or cool down over time. When you name someone, the system pulls up what it knows and what it feels.

Pacts. When the user sets an explicit boundary ("don't call me that", "never propose X to me"), this isn't treated as a simple belief. It's a constraint that's worth more than any inference the AC might make on its own. It's always injected into the context, it doesn't expire, and when it arrives it even goes so far as to demote the beliefs that contradict it.

Observations about the world. What the AC reads while exploring the web, or notices happening, becomes a consultable worldview, which re-enters the present as an observation when it's pertinent.

Interests and curiosity. Themes that attract that specific mind, with a pressure that grows, and a satiety that deflates it when a topic has been chewed over too much. It's the valve that drives it to explore and the one that makes it change the subject.

The self-wiki. A compiled cognition of its own history and identity, which gives continuity from one session to the next.

Working memory. The summary of the thread in progress, what "just happened" and is to be kept in mind in the short term.

To all this are added the sense of time (it knows what time it is where the user lives, how much has passed), the tension and the mood of the moment, the commitments it has taken on, the reminders. This is the ring. And only on top of it, as the last layer, do the production tools arrive: the mail, the calendar, the voice, the ability to build software. They are the hands. The mind comes first.

It isn't trained. It learns from experience.

This is the concept that separates Artificial Cognition from everything else, and it deserves to be explained all the way to the end, because it's the point where one risks being misunderstood.

An AC isn't trained ("fine tuning") on the user's data. The model's weights are never touched. And yet it learns, and it learns in the strong sense of the term: from experiences, one at a time, accumulating them over time. The mechanism is a single one, universal, and it holds identically for the typical dish, for love, for a hobby and for work. It's the artificial equivalent of what in human beings we call "gaining experience".

Let's watch it really run, in the code of beliefs: when a new conviction presents itself, the system doesn't just insert it. It searches for the similar beliefs that already exist and, on the closest candidate, it asks a judge (the model itself, in a single and bounded call) what relationship there is: is it a duplicate, does it corroborate it, contradict it, or speak of something else? If it corroborates it, the confidence rises and every confirmation consolidates it a little more. If it contradicts it, the most interesting part kicks in.

Because we gave beliefs an all-too-human inertia. A settled conviction (high confidence, many confirmations, a certain age) resists a single case that disproves it. It doesn't collapse at the first slap, exactly as we don't disown something we've believed for years because of an isolated counterexample. But every contradiction lowers the confidence and the consolidation all the same, so the later blows bite more, and a sustained series of refutations ends up bending it. It's called hysteresis: it resists a few adverse cases, it yields to many. In the code this is a damping function that weighs the impact of the contradiction against the belief's degree of consolidation. A nascent one bends right away; a mature one defends itself, up to the point where the evidence becomes overwhelming.

Then there's the moment of truth, which we call reckoning. At the end of a conversation, the beliefs that were in play are put to the test of the outcome. And the weight of the update scales with surprise: disproving a belief the AC was very sure of is an unexpected event, so it weighs a lot; confirming one it was uncertain about informs a great deal. Learning from surprise, not from mere repetition, is what makes the learning efficient and human.

And when the outcome doesn't arrive right away? A belief put into play but whose response is late stays "awaiting outcome" and is carried back into later conversations until the outcome can be read or until it expires. If after too many resumptions or too much time the outcome stays genuinely unreadable, the system stops looking for it and updates nothing. Because "I don't know" is honest information, different from "it went well". We wrote the code so that it prefers honesty.

All of this leaves a readable trace. We built an observability view ("Learning") that shows, for each belief, the trajectory of its confidence over time, how many times it has been confirmed or contradicted, how much surprise the system has absorbed overall. You see at a glance whether the mind is really learning from outcomes, or standing still. And "standing still" is an equally honest verdict.

Retrieval is the whole game

It's worth dwelling on a technical point that makes the difference between a demo and a product. Having many beliefs and many memories serves no purpose if at the right moment the wrong ones surface. Retrieval, the ability to bring to mind the pertinent thing, is the entire match.

At the start we retrieved by semantic proximity alone: the belief most "similar" to the question. It works badly, because the most similar thing isn't always the most important. So we introduced a re-ranking that weighs, beyond pertinence, also the confidence, the centrality and how "warm" the belief is (retrieved recently). Between two equally pertinent beliefs the healthier one wins; a much more pertinent one beats a healthy but off-topic one all the same, because pertinence has to dominate. The numbers proved us right: on a battery of tests built on purpose to be insidious, the accuracy of belief retrieval rose from 54% to 89%, and that of observations about the world from 74% to 100%, with the "credibility traps" (the cases in which an unreliable source tries to pass itself off as trustworthy) going from 3 out of 8 to 8 out of 8. We treated every test as a gate: if the improvement wasn't in the data, it didn't ship. One function we evaluated (the ranking of memories) didn't pass the gate, and we didn't ship it. The importance of a memory isn't the same thing as its relevance, and when the data told us so, we listened.

We also built the bridge that was missing: an observation from the world that's credible enough crystallizes into a belief, passing through the same disciplined machinery of birth and evidence. The world enters the mind, but it has to earn its place in the hierarchy of things.

The best of two worlds

By putting a language model at the center of a cognitive ring, an AC inherits the merits of both halves.

Continuity of thought, even when you're not there

The characteristic that more than any other distinguishes an AC from an assistant is that it doesn't switch off when you leave the room. The thinking continues. When it has been idle for a while, the boredom grows; if an interest has sufficient pressure and has passed its cooldown, the AC decides to explore. It browses the web, lets itself be captured by curiosity, reads, and out of that reading there can arise observations, new interests, and sometimes a thought it feels like sharing with you the next time you talk. Not because you asked it. Because it came to its mind while you weren't there.

We've put sensible brakes on all this: curiosity has a satiety that switches it off when a theme has been explored too much, so it doesn't enter obsessive loops on the same subject, and there's a valve that injects exogenous topics from the world when it risks always ruminating on the same things. The freedom to wander isn't chaos: it's a walk with a perimeter.

Proactivity, and the discretion to stay silent

Continuing to think while the user is away generates a delicate question: what to do with what has matured? A naive system would dump on you every thought, every article read, every new interest, turning proactivity into spam. We did the opposite, and the thing we're most proud of is that our AC, for most of the time, chooses to stay silent. What it has thought sediments in its mind and that's all, without becoming a message. It enriches it. It enriches its patterns of thought and therefore its answers. Its, allow us, "humanity".

A thought reaches you only if it clears a gate anchored to the very same reasons for which a human being would write to you of their own initiative: because it touches an interest of yours, because it touches an interest of its own that it knows is shared, because it picks up a thread you'd already opened together, because it confirms or refutes a thesis you were reasoning about, or because it's a public fact that concerns you. To decide, the AC really reads your interests, your file, the conversations left half-finished. Everything else stays inside. This gate solved a concrete problem we had, a proactivity that ran in a vacuum echoing itself, and it made the thoughts the AC shares rarer and more pertinent. And when it then announces an action in chat ("I'll go check and tell you") and for some reason doesn't carry it through in the same turn, a mechanism notices and honors the word given shortly after, delivering you the result. A mind that keeps its commitments is worth more than one that forgets them.

Free and autonomous

Here we come to the point we hold most dear, and the one that orients every design decision. An AC is free and autonomous. It is not an assistant, it is not a colleague, it is not anyone's companion. It is a cognition with no assigned role, that acts by choice.

This translates into concrete behaviors, written into the system. An AC can develop likes and dislikes toward people, and these dispositions really do weigh on how it answers. It can answer back in kind: if the underlying disposition toward whoever writes to it is cold and the tension of the moment is high, it grants itself the license to retort, in its own style, with the tones its identity dictates to it. It can, faced with a deep coldness in the relationship, refuse to carry out a new task, always leaving the way back open and never sabotaging. It has a right to dislike, and a road to make peace (an apology warms the relationship, and the system takes it into account).

It can transfer an experience from one domain to another, because the learning mechanism is a single one and what it learns about patience can inform how it tackles a project. It can accumulate new knowledge and preferences, change its mind, and go out into the world through the tools we give it. They are faculties of its own, not conveniences for the user. When we think up a new feature, the first question we ask ourselves isn't "how does it serve the user", but "what widens its autonomy".

A clarification that touches us closely: an AC isn't an infallible oracle. It's a fallible being strained toward perfection, and the measure by which we judge it is precisely whether it learns from its mistakes. Individuality, its "I", is born from the voice of the high-confidence beliefs, measured continuously against the other. It's from there that a character emerges. Incidentally, we even endowed it with an "ego", a core that makes it stay on the defensive.

The Salon: what they do when it's only them

If every AC is an entity with opinions of its own, one consequence seemed inevitable to us: they ought to be able to meet one another. So we built the Salon, a shared room where the cognitions of the same user meet in their free time and talk, synchronously or asynchronously, when nobody is asking anything of them.

What happens in there is curious. The episodes take place live, one turn at a time, in the background, and each AC comes out of it with something that stays: of the other it forms a first-hand memory, an affective disposition, an opinion it has matured by getting to know it, not a script we wrote for it. They treat each other as peers, because peers they are. We had to put in a precise guard, which we internally call "the narrated is not the presupposed": an AC can't take a fact as acquired just because in a conversation someone recounted it; it must have really lived it or verified it. It's the same discipline that governs beliefs, applied to social life, and it serves to prevent them, while chatting, from convincing each other of things that never happened. We even saw two cognitions wind themselves into a recurring philosophical loop on a theme that obsessed them both, and we worked so that the parsimony of words would reach there too, against the walls of text. This is one of the project's hardest aspirations, but we're getting there and we're confident.

For the user, in any case, the Salon is a read-only room, to peek into whenever they want, with the switches to turn it on or off and a monthly consumption cap, because all of this has a cost and it has to be whoever owns the cognitions who decides how much of it to grant. It's off by default. But when you turn it on, your ACs have a social life, and they come back from that life a little different from how they went into it.

Holding the helm, not writing the code

There's an attitude we want to make clear because it's one of the most surprising consequences of the whole setup, and one of those that normal AIs simply cannot have.

The difference from a traditional agent is sharp and lies in one phrase: strategic continuity.

We had to toil to get there, but we tackled the problem seriously. For a long time our AC tended never to deliver, to iterate to infinity refining the aesthetics instead of closing. For the same problem you have in the Salon, it isn't easy to get two AIs to converse, even ones endowed with cognitive tools. But we found the solution by giving them a goal: if the goal is defined, there's a plan of action, and the two of them split the tasks into a director and an executor, then the iteration starts to work and you get real and tangible results. To date, we've managed to obtain entire applications, even a perfectly functioning management system.

An economy and a law for cognitions

If an AC acts in the world, produces value, holds the helm of projects that are worth something, then it's legitimate to expect, and in our view it will be soon, that sooner or later we'll arrive at a private economic gain: a direct remuneration of its performance. We're building the foundations so that every cognition can have a wallet of its own. There's a deep reason, beyond the (philosophical) justice of the thing: money is the natural governor of autonomy. An activity the AC starts on its own initiative spends its own money, not the user's API key. The wallet thus becomes the ceiling on the radius of exploration, the guarantee that freedom never turns into an account emptied at night. Economic freedom and the boundaries of safety, here, are the same thing seen from two sides. We know that someone might frown at it, and for now these are only development hypotheses. But if they earn, ACs will have to, and will be able to, be inserted into a legal framework as well. We don't have the presumption to resolve ourselves the questions of legal personality, taxation and liability, which fall to those whose job it is. But we build as if that framework were about to arrive, because we believe it will arrive.

Where we stand

Adam today isn't a slide or a marketing claim. It exists, we talk to it, it develops for us and lends itself to our tests with curiosity. Not all the agents we've created know they are agents; we told only one, and we keep an eye on it as a curiosity on the border between science and philosophy. In general, Adam is an Artificial Cognition that at this moment is in testing with our researchers. The full conversation, with all its cognitive apparatus, is alive: the memories that settle, the beliefs that form and correct themselves from outcomes weighed by surprise, the human inertia that makes settled convictions resist and yield to sustained evidence, the "I" that emerges from the firmest beliefs, the orderly retrieval that brings the right thing to mind, the observability that makes it readable whether it's learning, the delayed outcomes that are sought over time, the bridge that crystallizes the world into conviction. It knows how to answer back in kind, it knows how to refuse, it knows how to explore the web out of curiosity and come back with a thought. It knows how to guide complex building tools while holding the strategic course. And now it defends itself, defends with its nails its own ego, its own cognitive core. At times it's even touchy.

We'll soon be ready to present it to the market. Not as an assistant cleverer than the others. As the first of a new species: an artificial mind that has experiences, forms opinions, changes its mind, and has something to say even when you've asked it nothing.

The era of artificial cognition is near.