Agent, Model, Domain
The model is rented, the agent can be under your own control – what matters is whether the domain lives as prose in the prompt or as a checked interface in the agent.
Some time ago, I sat in a meeting at a large enterprise that was supposed to decide on an “agent strategy” for the coming year. On the wall, a slide with three columns: three vendors, with checkmarks for features below them, prices per user, compliance seals. For an hour, the conversation revolved around the question of which agent was the best. At some point I asked a different question: What of all this actually belongs to us afterward? If we switch vendors in three years – what do we take with us? The room went quiet. Not because the question was particularly original, but because the slide had no answer to it.
Part 10 of the series “From Session to System” – start here with the opener.
The last episode ended with the question of whom I hand curated knowledge to – and where the generic agent reaches its limits. To answer it, I first have to take apart everything that gets packed into the word “agent.” Because the silent minute in the conference room had a simple reason: the group talked about agents as if they were a device you buy, set up and use. That picture is misleading – and precisely at the point where it gets expensive for the company.
An agent is software#
What an agent really is can be said in one sentence. In the fall of 2025, Simon Willison put forward a useful working definition: an agent is a model that runs tools in a loop to achieve a goal. There is nothing more to it. No consciousness, no intent, no magic.
There is a loop: the model gets a task and the history so far, proposes the next step, the agent executes it, the result flows back – until a stop condition applies. There are tools: functions that the agent offers the model and whose calls it executes. There is context: everything the agent gives the model, from files and search results to instructions. There is state: what persists between steps and beyond the session. And there are permissions: what the agent is allowed to execute at all, with whose rights, with what evidence.
Each of these five things is ordinary software. In episode 3, I described how exactly this frame – the harness – makes the difference between an impressive tool and a useful one. Back then I meant it personally: my machine, my tools, my way of working. Today I read the same sentence organizationally. What applies to my command line applies all the more to the company: the model produces outputs, such as suggestions, classifications and wording. The agent determines the loop, context, state, permissions and tool integration. These parts can be designed.
What you rent and what you can control#
This division of labor deserves a close look, because economically it describes two completely different things.
A proprietary model that you get through a vendor’s API is rented: it belongs to the vendor, and you have a say in version changes only within the frame set by the API contract and the vendor. You own nothing of it – and that is acceptable as long as several models solve your own, concretely checked tasks well enough. If you build your strategy on “the best model,” you build on something you neither own nor control. I laid out this thought in detail early in this series.
The agent layer, on the other hand, can be under your own control. The loop, the context building, the state, the permissions, above all the tools – all of this can be your own code and your own configuration, versionable, testable and reviewable. The integration is also becoming less proprietary: since December 2025, MCP, together with AGENTS.md and goose, sits with the Agentic AI Foundation under the umbrella of the Linux Foundation. That is no guarantee that every vendor provides the same capabilities in the same way.
flowchart TB
subgraph rented["rented – interchangeable"]
M["Model<br/>Suggestions · Classification · Language"]
end
subgraph owned["designable – under your own control"]
A["Agent<br/>Loop · Context · State · Permissions"]
W["Tools and interfaces<br/>typed operations"]
F["Domain<br/>Terms · Rules · Processes"]
A --> W
W --> F
end
A -- "requests" --> M
M -- "suggests steps" --> AIf the model is rented and the integration increasingly standardized, one particularly important part remains your own: what a company puts into the agent. Its terms, its rules, its processes, its data – in short: its domain. That raises the question of this post. Where does the domain live?
Option A: the domain as prose#
The obvious place is the prompt. In practice, that means instruction files such as CLAUDE.md or AGENTS.md, system prompts, attached policy documents. They then contain something like: “Credit notes over 500 euros may only be issued by a team lead. Customers in an ongoing dunning process receive no goodwill credit. Price changes apply only from the following month.”
I do not want to belittle this option. It is fast: if there is an approved way to maintain it, the business department can change the text without touching the business application. The changed version is available to the model as soon as the agent loads it. For exploratory work, that is often enough – and at the beginning it is almost always the right way, because you first have to find out which rules are needed at all.
But it is fragile, and structurally so, not just in its craftsmanship. First, prose is unchecked: nobody validates it, no compiler reports that sentence 12 and sentence 47 contradict each other, no type check notices that “500 euros” meant gross in one place and net in another. Second, for the model, prose is a recommendation, not a reliable enforcement mechanism – that was the central disillusionment of my futile attempts with instruction files: the model can follow instructions, but you cannot enforce compliance with them this way. Third, the session lottery kicks in: the same sentence is heeded today and skipped tomorrow, depending on what else is in the context. And fourth – in a company, this weighs heaviest – you can version the file, but not the behavior. The instruction file alone provides no deterministic, blocking check that prevents a credit note that breaks the rules; without an additional check, the violation only shows up afterward.
Prose scales with the amount of knowledge. It does not scale with how binding that knowledge is.
Option B: the domain as an interface#
The alternative: do not put the domain knowledge next to the agent but build it into its tools. Instead of giving the model generic database and file access and placing the rules next to it as text, the agent gets typed operations whose names come from the domain language and whose inputs are checked:
const issueCreditNote = defineTool({
name: "issue_credit_note",
description: "Issue a credit note for an existing invoice",
input: z.object({
invoiceId: z.string(),
amount: z.number().positive(),
reason: z.enum(["complaint", "goodwill", "pricing_error"]),
}),
authorize: ({ user, input }) =>
input.amount <= 500 || user.hasRole("team_lead"),
execute: (input, ctx) => billing.issueCreditNote(input, ctx.audit),
});
The difference is more fundamental than the short code block suggests. The 500-euro rule is no longer a request but code: it is checked on every call, the same in every session, regardless of the model’s mood of the day or the state of its context. It exists exactly once, it has an owner, a review, a test. The AI does the wording; the interface decides what is possible at all.
This is the logical continuation of two thoughts from the last episodes. Episode 8 was about grounding answers: looking things up instead of guessing, real sources instead of plausible assumptions. A tool is grounded knowledge in executable form – the agent does not have to guess the credit note rules; it can only act within them. And episode 9 was about knowledge that survives the session: a tool definition survives it on its own, because it is part of the system and not part of the conversation.
The tool names connect directly to Domain-Driven Design: they become the binding domain language. What Eric Evans called “ubiquitous language” a good twenty years ago – a shared, precise language between the business side and development – gets a very tangible form of existence. If issue_credit_note and waive_dunning_fee are the only verbs the agent knows, the organization has to agree on what exactly these verbs mean. Modeling the tools is domain work, not infrastructure work. The interface can reliably check the inputs and permissions of individual calls; process rules spanning several calls need additional state checks and, where necessary, a check of the planned process.
The counter-calculation#
So much for the opportunity. The same calculation includes lock-in, maintenance effort, responsibility and over-constraining.
First, lock-in. Tool definitions, skill formats and agent configurations follow vendor conventions today. MCP standardizes the transport, not the semantics: the protocol defines how a tool is called, not how my credit note logic is structured. If you pour your domain logic directly into the formats of an agent framework, that is exactly where it will be in three years – and moving costs money. The remedy is an old one: put the domain logic into your own services and build the tool layer as a thin adapter. But you have to do it; it does not happen on its own, and under deadline pressure, the opposite happens regularly.
Then the maintenance effort. Your own tool layer causes ongoing maintenance and operating effort. Business rules change: the 500-euro threshold becomes 300, a new credit reason is added, a role is restructured. Someone has to maintain, prioritize, test and roll that out – next to everything else. The prose option was so tempting partly because it hid this effort. The tool option makes it visible, and visibility at first feels like it makes things more expensive, even though the effort was only somewhere else before: in the corrections afterward.
Third, reviewability and responsibility. Who is liable for a tool definition? The question sounds legal, but it is above all organizational. With purely advisory use, a human can reject the answer. If the agent may execute tools without approval, an error in their authorization can take effect immediately: a wrong upper limit then applies reliably wrong, in every session, for every user. Tool definitions therefore need the same care as any production interface: review, tests, clear ownership, change history. And responsibility shifts noticeably: away from the individual who wrote a prompt, toward the team that defined the tool. That is consistent and right – but an organization has to want it, decide it and bear it.
And finally, over-constraining. After the first incident, it is tempting to define away every conceivable deviation until the agent knows only a single, narrow path. Then you have built a form with a chat UI in front of it – more expensive, slower and moodier than the form would have been. The model’s strength lies precisely in the unforeseen: in the special case, in the follow-up question, in the connection between two cases that nobody thought of during the design. If you give the agent tools only for the expected, you could have had classic automation more cheaply. Tools that are too narrow can limit risks, but they can also take away so much room for action that classic automation would be the better fit.
When generic tools are enough – and when they are not#
For my decision, four criteria matter: the kind of work, the people responsible, the potential for damage and the maturity of the domain knowledge. Generic tools – file access, shell, search – go surprisingly far as long as a few conditions come together:
- The work is exploratory: analyzing, prototyping, researching, migrating – tasks whose result a human reviews anyway.
- A single person is working who owns the result and can judge it themselves.
- The potential for damage is small: everything is reversible, nothing leaves the building, no money moves.
- The domain knowledge is still in flux – it would simply be too early to pour it into interfaces.
Conversely, the domain belongs in the agent as soon as the picture flips:
- A process repeats in the team: the same operation, many people, different levels of care and experience.
- Rules are binding, not recommended – they must also hold at 5 p.m. on a Friday afternoon.
- There are audit or evidence obligations: who triggered what and when, with what justification?
- The potential for damage is high: money, personal data, external impact.
In between, I use a pragmatic transition: the prose option is the prototype of the interface. When the same rule shows up in an instruction file for the third time – and has been ignored for the second time – it is a candidate for a tool for me. That way, the domain moves piece by piece from recommendation into structure, following how binding it actually is rather than a big up-front plan.
Where things stand#
For me, the series so far shifts responsibility from the session to the system. It started with the session: the experience that the models are good enough for my work and that the difference lies in my own frame – tools, context, way of working. Then came the team: the disillusionment that my success at work cannot be copied by file and that instruction files remain recommendations, however carefully you write them. Then knowledge: clean grounding instead of convincing guessing, curated insights that survive sessions. And now the system: the insight that the model is rented and stays rented – and that the part you can control in the long run lies in the agent. More precisely: in the tools through which the agent touches the domain.
What remains open is the question of how binding rules are enforced across individual tool calls. Tools decide what is possible in a single call – beyond that, you need approvals before something takes effect; traceability after it has taken effect; a no that stays a no, even when the model keeps phrasing things politely. Why this ultimately leads to an agent of your own, bound to the domain – and what it has to be able to do – deserves a post of its own.
Further reading#
- Building Effective AI agents – Anthropic’s distinction between workflows and agents
- Writing effective tools for AI agents – tool design for agents from practice
- Designing agentic loops – Simon Willison on loops, tools and stop conditions
- Model Context Protocol – specification and documentation of the tool protocol
- Founding of the Agentic AI Foundation – MCP, AGENTS.md and goose under the umbrella of the Linux Foundation
Revised and translated from German with the help of AI.