Skip to content

Tools that hold up: concepts, methods, processes

You cannot install an agent for your own business domain – but you can very well learn the way there. Which concepts hold up, which methods keep the start small and which processes prevent rules from going stale.

Tools that hold up: concepts, methods, processes

You cannot install an agent for your own business domain – but you can very well learn the way there. Which concepts hold up, which methods keep the start small and which processes prevent rules from going stale.

Between “we have understood what such an agent is” and “we have one” lies a step that no plan answers. The pattern returns in almost every conversation I have on the topic: someone has sketched the whole organization as a future landscape of agents – a dozen domains from “accounting” to “support”, with arrows, queues and a shared knowledge store in between. A well-considered sketch, with real thinking in it. And then the one question: Which domain comes first? The plan answers everything – except the first step.

Part 12 of the series “From Session to System” – here is the opening article.

The previous part described what an agent must be able to do when it represents a business domain bindingly: 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 is the way there – and that is exactly where the beautiful sketch fails. 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 when attention moves on. One after the other.

Concepts: none of this is new#

If you go through the list of capabilities from the previous part, 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 these terms are unambiguous only within a defined context – were described by Eric Evans a good twenty years ago as ubiquitous language and Bounded Context. The separation of proposal and effect is known to every organization that first reviews changes and then rolls them out, from the four-eyes principle in bookkeeping to terraform plan and apply. Validation, authorization and audit are the tools of the trade of every 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 by the middle parts – at its core documentation and library work, nothing mysterious.

The only new thing is the consumer: a loop in which a model acts, instead of an interface in which people click. For the choice of concepts that is a small shift. Since then a simple test question has helped me: Did this concept already hold up before there was AI? Domain boundaries, approval workflows, versioning, audit – yes, for decades. An “agent mesh orchestration framework” that has existed for four months – rather not. That is no dismissal of the new; somewhere the next concept that holds up is in fact emerging right now. But the burden of proof lies with the new, not with the proven.

For the landscape with the dozen domains there is an old concept too, and it hits harder than any technical question. John Gall put it into words in the seventies: A complex system that works has invariably evolved from a simple system that worked. A complex system designed on the drawing board does not work and cannot be repaired either – you have to start over, with a simple system. The landscape of agents was the drawing-board design. The first box that really runs 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 part was: Which rules belong in the path, which may remain prose? The answer does not begin with technology but with taking stock. Rules live in four places today: in the wiki, in instruction files such as CLAUDE.md or AGENTS.md, in code review comments – and in heads, as the knowledge of the one colleague you ask before every price change, to be on the safe side. The inventory brings them to one place and notes four things for each rule: Where is it written down? How binding is it meant to be? What happens when it is violated? And how often has it actually been violated recently?

The last column is the most important one, because it replaces opinion with findings. In the chronicle of my instruction files the sobering part was that written rules remain recommendations; in the part 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

Three questions have proven useful for the classification, and they match the criteria that have emerged in this series: Does a violation move money, personal data or an effect toward 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 one of these questions, and the rule belongs in the path: check, approval, evidence. Three times no, and it remains prose – as a convention that the model reads and mostly follows, and where an occasional outlier hurts nobody.

The inventory has a second yield that I had not counted on: it finds dead rules. Requirements that nobody has needed for years, whose occasion disappeared long ago, but which are still carried along in every document. They are thrown out – not into the path, but entirely. An agent that represents a business domain is also an opportunity to clear out 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 a department. “Accounting” is not a cut but a box on the org chart. “Credit notes and dunning holds” is a cut – a process that can be delimited, with a beginning, an end and a handful of verbs.

How to 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: if the list of tools reaches double digits while modeling, the cut is too big.
  • There is already a person responsible for the domain today – the role that approves and decides even without AI.
  • The pain is documented: violations really happened in the past and demonstrably caused annoyance.
  • The potential damage justifies the effort but stays manageable – credit notes yes, payment transactions with other countries perhaps only in the second year.

The last point deserves a moment. The first domain agent is not only a tool, it is also the practice piece on which you build and operate the three capabilities – check, approval, evidence – for the first time. You choose practice pieces so that mistakes are instructive, not a threat to your existence.

A small cut also comes with a small transition. Nobody tears down the existing way of working and replaces it with the agent; the prose variant 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 dispensable – 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 only the documentation of the check. No big cutover day, no risky migration over a weekend.

This is how the dozen domains become one, and even that one gets smaller: not “accounting” but goodwill credit notes. The rest of the sketch does not die – it becomes the backlog, sorted by exactly the criteria above. At first that sounds like a retreat. It is the opposite: the first step that can actually be taken.

Processes: owners, approvals, rhythm#

That leaves the third kind of tool, and it is the one most easily underestimated. Concepts can be learned, methods can be applied – processes have to be sustained. Three have proven to hold up.

First: Every rule has an owner, and that owner sits in the business unit. Development 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, which has always carried this responsibility. The previous part ended with the observation that the half hour for the sum check was the easy part and the discussion about proposing, checking and approving rules the long one. This discussion is not an obstacle on the way to the process. It is the process – whoever skips it has rules without legitimacy, and they erode at the first conflict.

Second: Changes to rules take the same path as rules. Proposal, check, approval, versioning – the same care that goes without saying for code. That the evidence records the rule version in force was a detail on the margin in the previous part; in operation it becomes the precondition for being able to touch rules at all without reinterpreting the past.

Third, and most important: learning from the noes, in a fixed rhythm. In operation the agent produces two streams – executions and rejections. The rejections are the more valuable material. Every few weeks the rejection log belongs on the table, 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 show up so regularly that they deserve a verb of their own? This is the same cycle that the part about curated knowledge described, only with rules instead of insights: operation supplies candidates, curation turns them into something binding – and the organization gets smarter, not the model.

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 in rhythm<br/>learn from the noes"]
    S --> I

Together the three processes yield what the previous part only claimed: that such an agent is a product with a lifecycle. A product has owners, a path for changes and a cadence in which it gets better. If one of them is missing, it decays – faster with rules than with code, because nobody gets a build error when a threshold no longer fits reality.

A fashion you can skip#

And the counter-list? What costs attention without advancing any of the three capabilities?

The multi-agent orchestra from day one – the landscape from the beginning cast in software, a dozen agents sending each other messages before even one of them enforces a single binding rule. The weekly change of framework, with the business logic sinking a little deeper into vendor conventions each time; the antidote – business logic in services of your own, the tool layer as a thin adapter – was already in the part about agent, model and business domain. The model comparison table as a substitute for strategy, which this series argued against early on: whoever checks their tasks concretely usually finds that several models solve them well enough – and that the energy belongs in their own share. And the endless polishing of wording: When the same instruction is rephrased 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 to build check, approval or evidence – or does it only feel like progress? Much of what is loud right now can be left to mature in peace. It will not run away, and whatever part of it holds up will still be there in a year.

Where things stand#

With that, the three questions from the end of the previous part are answered, as well as I can after these months. Which rules belong in the path is decided by an inventory with findings instead of opinions. You cut the first domain as one process with a handful of verbs, on which mistakes stay instructive. And what keeps the whole thing alive are unspectacular processes: owners, a path for changes, a rhythm for the noes. The concepts behind them are old, and that is their most important property – they have held before.

The series has thus reached a point where the arc can be closed. A good eight months ago it began with a session on my computer and the observation that my work is changing; now the path ends, for the time being, with organizations that place rules, knowledge and responsibility in agents of their own. Time to take honest stock: Which of the expectations of the opening article came true, which did not – and where does all this lead? That is what the next part is about.

Further reading#