Tools That Hold Up: Concepts, Methods, Processes
You cannot install an agent for your own domain – but you can very well learn the way there. Which concepts hold up, which methods keep the start small and which processes keep rules from going stale.
There is no installation package for an agent that represents a domain in a binding way. You can install available model weights and runtimes; you can implement or connect protocols. Model weights and runtimes alone, however, do not enforce a domain approval and do not produce meaningful domain evidence of who decided what. The binding part only emerges when you engage with your own domain – with its terms, its rules and the people who stand behind both. The way there can be learned, though, and it is less spectacular than many framework debates suggest.
Part 12 of the series “From Session to System” – start with the opening post.
The previous post described what such an agent has to be able to do: check plans before they take effect; approvals that no model can talk its way around; evidence that answers the questions of the day after tomorrow. What remained open was the way there. It leads through three kinds of tools: concepts that hold up. Methods that keep the start small. And processes that keep the whole thing alive in operation once attention moves on. One at a time.
Concepts: none of this is new#
If you go through the list of capabilities from the previous post, you will not find a single AI invention in it. Domain language and domain boundaries – that a system should speak the terms of its domain and that those terms are only unambiguous within a defined context – were described by Eric Evans a good twenty years ago in “Domain-Driven Design” as ubiquitous language and bounded context. Every organization that reviews changes before rolling them out knows the separation of proposal and effect, from the four-eyes principle in accounting to terraform plan and apply. Validation, authorization and audit are the basic toolkit of any serious business application. And that answers have to rest on real sources instead of plausible guessing and that curated knowledge needs a cycle with owners was covered in the middle posts of this series – at its core that, too, is documentation and library work, not magic.
The only new thing is the consumer: a loop in which a model acts, instead of a UI where people click. For choosing concepts, that is a small shift. Since then, one simple test question has helped me: did this concept hold up before there was AI? Domain boundaries, approval workflows, versioning, audit – yes, for decades. An orchestration framework that has existed for four months – probably not. That is not a dismissal of everything new; somewhere the next concept that holds up is actually emerging right now. But the burden of proof lies with the new, not with the proven.
A natural building block shows that the old concepts carry over directly into agent systems: a workflow engine can separate mission, plan, run and the authority granted for it – and use the same planning path for HTTP, MCP, A2A, webhooks and chat. That is the old separation of proposal and effect, applied consistently to every input channel: no matter where an initiative comes from, it takes the same planning path.
For the reflex to design the whole organization as an agent landscape right away, there is an old concept as well, and it hits harder than any technical question. John Gall phrased it in the seventies as an observation about systems: “A complex system that works is invariably found to have evolved from a simple system that worked. A complex system designed from scratch never works and cannot be patched up to make it work. You have to start over, beginning with a working simple system.” Twelve connected agents on a whiteboard are the design from scratch. The first process that actually runs and delivers a verifiable result is the beginning of the system.
Method: take inventory of the rules first#
The first of the three questions from the end of the previous post was: which rules belong in the path, and which may stay prose? The answer does not start with technology, but with an inventory that is less popular than it needs to be. For the inventory, I would first check four places: the wiki, instruction files such as CLAUDE.md or AGENTS.md, code review comments – and heads, as in the knowledge of that one colleague you ask before every price change, just to be safe. This list is not complete; depending on the organization, tickets, policies, configuration or business procedures come on top. The inventory brings the rules into one place and notes four things for each: where is it written? How binding is it meant to be? What happens if it is violated? And how often was it actually violated recently?
The last column is the most important, because it replaces opinion with findings. In the chronicle of my instruction files, the sobering lesson was that written rules remain recommendations; in the post about tools, that turned into a transition criterion: 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 enforcement in the path. The inventory turns this gut feeling into a list:
# rule inventory, one entry per rule
- rule: "Credit notes above 500 EUR require team lead approval"
source: wiki, AGENTS.md
violation_impact: money leaves the company
violated_recently: twice in Q2
decision: enforce # goes into the path
- rule: "Use the customer number, not the invoice number, in replies"
source: onboarding notes
violation_impact: confusion, no damage
violated_recently: unknown
decision: prose # stays a convention
For classifying them, I consider three questions a solid starting point, and they match the criteria that have gradually emerged in this series: does a violation move money, personal data or effects to the outside? Does someone have to be able to prove afterwards who decided what and when? Was the rule broken repeatedly despite clean documentation – by people or by the model? A yes to any of these questions is my starting point for taking the rule into the path: check, approval, evidence. It remains a starting heuristic, though – where the possible damage is small, a mistake is easy to undo or existing controls catch it anyway, a rule can stay prose even with a yes. Three times no, and it stays prose – as a convention that the model reads and mostly follows, and whose remaining risk has been explicitly accepted.
The inventory has a second yield that is easy to overlook: it finds dead rules. Requirements that nobody has needed for years, whose reason disappeared long ago, but which are still dragged along in every document. Those go – not into the path, but out entirely. An agent that represents a domain is also an opportunity to declutter the domain itself.
Method: cut the first domain small#
The second question: how do you cut the first domain without overreaching? The short answer: one process, not one department. A department bundles many states and responsibilities that are never finished at the same time; a process has a verifiable beginning and a verifiable end. “Accounting” is therefore not a cut but a box on an org chart. “Credit notes and dunning stops” is one – a well-delimited process with a beginning, an end and a handful of verbs.
How you recognize a suitable first candidate:
- The process has a clear beginning and a clear end – no permanent state, no umbrella term.
- A handful of verbs is enough: at the latest when the tool list reaches double digits during modeling, I would review the cut again.
- There is already a person responsible for the domain today – the role that approves and decides even without AI.
- The pain is documented: violations have actually happened in the past and demonstrably caused trouble.
- The damage potential justifies the effort but stays manageable – credit notes yes, international payments maybe only in the second year.
The last point deserves a moment. The first domain agent is not just a tool; it is also the piece on which a team builds and operates the three capabilities – check, approval, evidence – for the first time. You choose such first pieces so that mistakes are instructive, not existential.
A small cut also calls for a small transition. Nobody tears down the existing way of working and replaces it with the agent; the prose version remains the prototype from which rules move into the path one by one, as soon as their binding nature has been proven. For this pattern – the new grows along the old until the old is no longer needed – Martin Fowler coined the image of the strangler fig that grows around a tree. Applied to rules: first the 500 euro rule applies as a sentence in the instruction file, then additionally as a check in the path, and at some point the sentence is just documentation of the check. No big switchover day, no risky migration over a weekend.
The rest of the big sketch does not die in the process – it becomes backlog, sorted by exactly the criteria above. That can feel like a retreat. It is the opposite: the first step that can actually be taken and delivers a verifiable result.
Processes: owner, change path, rhythm#
That leaves the third kind of tool, and it is the one most easily underestimated. You can learn concepts, you can apply methods – processes you have to sustain in operation. I consider three of them load-bearing.
First: every rule has an owner, and that owner sits in the business unit. Engineering owns the enforcement – the code that checks, the gate that waits, the log that writes. But whether 500 euros is the right threshold, whether “goodwill” and “pricing error” take different paths, is decided by the business side that has always carried this responsibility. The discussion about proposing, reviewing and approving rules is not an obstacle on the way to the process. It is the process – if you skip it, you have rules without legitimacy, and they erode at the first conflict.
Second: rule changes take the same path as rules. Proposal, review, approval, versioning – the same care that is a given for code. That the evidence records the rule version in force was a side detail in the previous post; in operation it becomes the precondition for touching rules at all without reinterpreting the past. Two building blocks show what this can look like: a knowledge system can keep domain guidelines in a versioned charter that people are responsible for, and route changes to the derived knowledge base through a review process. A workflow engine can describe approved procedures as workflows that run repeatably and log every run – work that has not been described and approved is not improvised. Both are expressions of the same principle: the change path is built into the system.
Third, and most important: learn from the noes, at a fixed rhythm. In operation, the agent produces two streams – executions and rejections. For rules that are too narrow or missing, the rejections are often the more fruitful starting point; samples of successful runs are still necessary, because an execution that was waved through can also contain a wrong decision. The rejection log therefore belongs on the table regularly – at first at a fixed interval of a few weeks, later depending on the rejection rate and damage potential – with three questions: which noes were right and stay? Which were too narrow and need an adjusted threshold or a new reason for a credit note? And which special cases come up so regularly that they deserve their own verb? This is the same cycle that the post about curated knowledge described, just with rules instead of insights: operations deliver candidates, curation turns them into something binding – the organization changes rules and interfaces in the process; the model stays unchanged.
flowchart LR
I["Inventory<br/>collect and assess rules"] --> K["Classification<br/>path or prose"]
K --> B["Build<br/>verbs · check · approval"]
B --> O["Operation<br/>executions and rejections"]
O --> S["Review at a rhythm<br/>learn from the noes"]
S --> ITogether, the three processes deliver what the previous post merely claimed: that such an agent is a product with a lifecycle. A product has owners, a change path and a cadence at which it gets better. If one of these is missing, it decays – faster with rules than with code, because an outdated threshold does not fail a build and therefore has to be caught deliberately through review or operational metrics.
Fads you can skip#
And the opposite list? I consider four patterns attention sinks that improve neither check nor approval nor evidence – that is a judgment, not a measurement.
The multi-agent orchestra from day one: many agents sending each other messages before even one of them enforces a single binding rule – the design from scratch cast in software. Frequent framework switching, where the domain logic sinks a bit deeper into vendor conventions each time; the antidote – domain logic in your own services, the tool layer as a thin adapter – was already in the post about agent, model and domain. The model comparison table as a substitute for strategy, which this series argued against early on: whether several models solve your own tasks well enough is shown by a concrete check against exactly those tasks – and where that is the case, the energy belongs in your own share, not in the table. And endless polishing of wording: when the same instruction is reworded for the third time so that the model “finally understands” it, that is not a writing problem. It is the signal that the rule belongs in the path, not in nicer words.
The test question is always the same, and it keeps the list short: does it help build check, approval or evidence – or does it just feel like progress? Many of the frameworks and agent patterns currently under discussion can be left to mature in peace. They are not going anywhere, and whatever holds up will still be there in a year.
Where things stand#
With that, the three questions from the end of the previous post are answered, as well as I can after these months: with an inventory that delivers findings instead of opinions, a cut the size of one process, and processes that define owner, change path and rhythm. So I would start with a documented rule violation in a process that has already been cut small – that is where the pain is documented, the cut is small and the result is verifiable. The concepts behind it are old, and that is their most important property: they have held up before.
A good eight months ago, this series began with a session on my computer and the observation that my work was changing; now the path ends, for the time being, at organizations that put rules, knowledge and responsibility into their own agents. The next post checks the expectations from the opening: what came true, what did not – and where does all of this lead?
Further reading#
- Domain-Driven Design Reference (Eric Evans) – ubiquitous language and bounded context as design work
- John Gall: Systemantics – why working complex systems evolve from simple working systems
- Martin Fowler: Strangler Fig Application – the pattern for transitions without a big switchover day
- Building Effective AI Agents (Anthropic) – the advice to start with the simplest setup that works
Revised and translated from German with the help of AI.