The Professional's Bot: Built, Not Trained

Everyone wants a bot, few know what makes it reliable

For a few months now, the request has come back almost identically. A professional—a lawyer, a consultant, an architect—wants an AI assistant to answer client questions, summarize their skills, filter requests, and explain how they work. And almost always, the request comes with a pre-selected word: "train it." The implicit idea is that there is a model to be instructed on one's documents until it learns to be us.

It is an understandable instinct, but it aims at the wrong place. The problem with a bot representing a person is not how smart it is, because today's models are already smart enough. The problem is how faithful it is: an assistant that invents a skill, misquotes a judgment, or remains stuck in last year does not protect a professional's reputation—it damages it. And fidelity is not achieved by making the model smarter, but by structuring what the model reads before it speaks.

What the professional's bot is, and what it is not

The professional's bot is not a generic chatbot with a label on it, and it is not a model "that has studied you." It is a capable model put in a position to respond like that professional because it has in front of it, in a readable form, the structured and verifiable set of who they are, what they do, with what credentials, under what conditions, and with what evidence.

The distinction matters because it separates two very different tasks. One is choosing the engine, and that is the easy part and largely solved by the market already. The other is building the knowledge that the engine must use, and that is the hard part—the one that decides whether the bot will be precise or approximate. The value is not in the engine; it is in the core of knowledge that gives it identity.

Intelligence is borrowed, identity is built

To frame this point, I will rely on a framework that Andrej Karpathy has focused on over the past year, as it has the merit of organizing ideas without fanaticism. Karpathy distinguishes what a model knows through training from its ability to reason, observing that true general intelligence depends more on the "cognitive core"—that is, abstraction and problem solving—than on the quantity of memorized facts.

The consequence is liberating. You don't have to build the bot's intelligence; that already exists in the model, and you borrow it. You must provide the identity: the specific knowledge of the professional, which no general model possesses and no one expects to find in its weights. In other words, laboratories graduate the capable university student; it is up to you to turn them into the precise professional by providing the right data and context. This, to use Karpathy's words again, is precisely the function of applications built on top of models: organizing a generalist and animating them into a vertical professional.

RAG fills the working memory, not the knowledge of you

Here a common misunderstanding must be cleared up, without falling into the opposite excess. In the last two years, the standard way to feed documents to a model has been RAG (Retrieval-Augmented Generation): we search for relevant texts and insert them into the context at the moment of the query. It works, and it is useful. But it must be understood for what it is.

In the metaphor Karpathy uses to describe these systems, the model's weights are like the CPU, the context window is like the RAM, and the prompt is the program. RAG fills the RAM: it brings in the right documents for the duration of a response, then the session closes and that memory vanishes. It is precious for giving the bot materials to reason on, but it does not make it "know" the professional in a stable way, and its quality depends entirely on how structured and reliable the sources you provide are. In short, RAG is a component of the professional's bot, not its identity.

Training the model: the temptation that promises too much

The alternative many imagine is the opposite: actually training the model on the professional's data, modifying its weights through fine-tuning. Here too, a measured stance is needed, because fine-tuning has a legitimate use—teaching a style or habitual behavior—but it is the wrong lever for the goal we are talking about.

Three reasons, all practical. Weights are opaque: you cannot show a client why the bot said a certain thing, which is a problem, not a detail, for those who make verifiability their brand. Updating them is expensive: every time a service, tariff, or qualification changes, you would have to redo the training. And above all, models today do not have continuous learning. Karpathy describes this with a sharp image: anterograde amnesia. An LLM does not consolidate what you tell it over time on its own; it doesn't have a "sleep" phase that turns context into long-term memory. Training weights on a single person is therefore expensive, fragile, and opaque. It promises a bot "that has learned you"; it delivers a bot that is hard to inspect and keep up to date.

The missing layer: explicit and verifiable knowledge

Between RAG, which fills the working memory, and fine-tuning, which modifies the weights, there is an intermediate layer that is decisive. It is explicit, readable, and modifiable knowledge that declares what is true about the professional and with what sources it is demonstrated.

Karpathy proposed, as an intuition rather than a consolidated technique, the idea of "system prompt learning": much of the useful learning looks more like rewriting one's own explicit manual than changing weights—as if the model were writing itself the book of how to approach a problem. I quote it for what it is, a research direction, but it points precisely to the layer we need to work on: a declared memory, in clear text, that can be read, corrected, and verified. This is exactly the layer that those who build semantic identities know how to handle, because it is made of the same material: deciding what to assert and anchoring it to evidence.

An example: declared competence as data

It is just like an organization's values. If a data point remains only in texts written for humans, a machine must infer it; if you declare it in the structure, it treats it as fact. A professional's competence can be written in a biography, and then an agent interprets it, or it can be stated in data, and then the machine reads it without ambiguity.

{
  "@type": "Person",
  "name": "...",
  "jobTitle": "Avvocato",
  "knowsAbout": ["diritto della concorrenza", "contrattualistica IT"],
  "hasCredential": {
    "@type": "EducationalOccupationalCredential",
    "name": "Iscrizione all'Ordine degli Avvocati"
  },
  "sameAs": ["https://www.wikidata.org/wiki/Q...", "https://www.linkedin.com/in/..."]
}

A bot drawing from such a declaration does not have to guess what the professional is competent in, where their authority comes from, or how to verify it: it finds it asserted, typed, and linked to controllable entities and registries. The biography speaks to the human, the structure declares to the machine, and the bot responds on foundations that can be shown.

The bot is the entity made queryable

Seen this way, the professional's bot is not a separate object from the work on digital identity; it is its natural continuation. In a previous note, I described the transition to Business to Agent, the world where the professional must become readable by AI agents. The bot is the next step: from readable to queryable, from an entity that an agent consults to an entity that dialogues.

And building it does not require inventing a new service. It requires putting together four things I already do. Structured data in JSON-LD shapes the professional's truth. Anchors to verified entities, on Wikidata and official registries, make it quotable and strip the bot of the temptation to hallucinate. Queryable knowledge bases—the professional's materials reorganized for the model to access—are the well-built working memory. And semantic automation keeps the whole system alive, updating data when content changes and monitoring how the bot describes the professional over time. The bot is the composition of these layers, not an isolated fifth piece.

Fidelity is maintenance, not an installation

From this also follows what is honest to promise. A faithful bot is not installed once and forgotten. Because models do not have continuous learning, the update layer must be kept alive manually: it is the continual learning that the machine does not do on its own and that becomes our job. This is not a limitation to hide, it is the value of the service, because it makes the relationship recursive rather than a one-off sale.

Similarly, it makes no sense to promise a bot that never errs. It makes sense to promise a bot whose answers are anchored to declared sources, where one can trace what it asserts and correct it where needed. Trust, for a machine, is not a perception to suggest, but a chain of verifiable assertions. That is where the credibility of an assistant carrying a person's name is won or lost.

Why it pays to move now

One might think all this concerns a distant tomorrow. It does not, and neither does the opposite. Karpathy invites calm regarding timelines, speaking of an "agents decade" rather than a single year, because there is still a long way to go. But precisely for this reason, the window is now: the infrastructure allowing models to connect to data and tools is arriving, while the structured knowledge of most professionals is still poor or absent.

There is also a fact that downsizes the technical fear. Karpathy showed with nanochat that today a small conversational model can be trained from scratch for about a hundred dollars in a few hours: the capacity to build engines is no longer the bottleneck, and because of this, competitive advantage shifts upstream, to the quality of the knowledge you feed the model. Those who declare their identity early in a verifiable way will be among the few clear references when bots and agents begin operating on a large scale. A structured declaration, unlike a campaign, does not stop working when you stop paying for it: it deposits and reinforces itself over time.

Where to start

The first step is always the same, and it is simple. Ask the main AI systems what they know about the professional today, and observe what is correct, what is missing, and what is invented. That snapshot tells you exactly how much of your professional identity you are already delegating to the machine, and with what fidelity.

From there, the work is declaring what you want to be treated as fact—competences, titles, fields, evidence—linking it to the right entities and verifiable sources, and building the bot on top of this base, rather than hoping a model learns by itself to be us. You don't train a brain on a person. You build the verifiable core of knowledge that makes a capable AI speak like that person, and you keep it alive.

The evolution toward intelligent agents represents the new frontier of GEO (Generative Engine Optimization), redefining how brands declare their identity and offer to machines.

Essential references

• Karpathy A., «2025 LLM Year in Review», December 2025 - karpathy.bearblog.dev
• Karpathy A., interview with Dwarkesh Patel (decade of agents, continuous learning), October 2025 - dwarkesh.com
• Karpathy A., «Software 3.0», YC AI Startup School, June 2025 - youtube.com
• Karpathy A., note on «system prompt learning» as the missing paradigm, X, May 2025 - x.com/karpathy
• Karpathy A., «nanochat», open source repository, 2025 - github.com/karpathy/nanochat
• Lewis P. et al., «Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks», NeurIPS 2020 - arxiv.org/abs/2005.11401
• Anthropic, «Introducing the Model Context Protocol», 2024 - anthropic.com