This article follow on from the Agent Design Maturity Ladder:
Most teams skip Phase 0 of Agent Design because it feels like delay. They want prompts. They want tools. They want visible progress.
They want to get their hands dirty and as agent toolkits advance the pseudo sense of progress can be intoxicating. Until you hit the wall.
At that point what they get instead is an agent that behaves confidently wrong — fluent in language, ignorant of reality, and dangerous precisely because it sounds competent.
Phase 0 is about avoiding this wall, and it iis not about agents at all.
It is about establishing the world an agent will inhabit — its physics, its language, its hazards, and its values — before you give anything the power to explore and act.
If Phase 1 is prompting, Phase 0 is ontology.
If Phase 2 is tools, Phase 0 is permission.
If Phase 3 onwards is autonomy, Phase 0 is responsibility.
Skip Phase 0, and every later phase compounds error.
Phase 0 is the pre-design phase of agent engineering. Not architecture. Not prompts. Not frameworks.
It is the disciplined act of answering one question:
“What must be true about the world for this agent to act safely, usefully, and intelligibly?”
This phase produces constraints, not capabilities. Domain to prevent danger.
Meaning before mechanism.
Phase 0 work is done with humans, not models.
Agents do not operate in “tasks”. They operate in domains — structured worlds with rules, entities, and consequences.
Strong Phase 0 questions include:
What domain does this agent exist within?
What is in scope — and what is explicitly out of scope?
What entities matter here?
(People, artefacts, states, approvals, risks, policies)
What relationships between those entities are real, causal, and important?
What actions are even possible in this world?
If you cannot describe the domain without referencing the agent, you are not ready to build one.
LLMs are language machines — but language without grounding is hallucination.
Phase 0 asks:
What terms have precise meaning in this domain?
Where do humans routinely disagree on definitions?
Which words are overloaded, informal, or context-dependent?
What does “done”, “approved”, “safe”, or “urgent” actually mean here?
This is where most agent failures are born: the model is fluent, the organisation is ambiguous.
Phase 0 is where ambiguity is exposed, not hidden behind prompts.
Agents don’t create value. They amplify the value logic already present — good or bad.
Phase 0 questions include:
Who is this agent for?
What human pain or friction are we trying to relieve?
What outcome would make a user say: “This helped.”
What outcomes would be technically “correct” but humanly wrong?
How will we measure success without relying on activity metrics?
If you cannot articulate value without mentioning automation, stop. You are, at best, designing motion, not progress.
Phase 0 is where you imagine failure before intelligence is applied.
Questions to ask include:
What is the blast radius if this agent is wrong?
What errors are recoverable — and which are not?
What actions should never be taken automatically?
What does a graceful failure look like here?
When should uncertainty trigger escalation rather than action?
Autonomy is not a reward. It is a liability you earn the right to carry.
Agents must know where reality lives.
Phase 0 insists on clarity:
What are the authoritative sources of truth?
Which sources conflict — and how do humans resolve that today?
What knowledge is static vs temporal vs contextual?
What knowledge is implicit in human heads but absent from systems?
If the organisation itself does not know where truth resides, the agent will invent it. And it will sound convincing while doing so.
Done well, Phase 0 produces:
A shared domain model
Explicit constraints and invariants
Clear non-goals
A list of known ambiguities
A definition of safe failure
Agreement on where humans stay in the loop
None of these are prompts. All of them shape every prompt that follows.
When you hear some of the following, beware:
“We’ll figure it out in the prompt.”
“The model will infer that.”
“Let’s just prototype and see.”
“It’s just internal — low risk.”
“We’ll add guardrails later.”
These are not shortcuts. They are deferred disasters.
Run Phase 0 as a facilitated workshop, not a solo design task
Use real incidents and failures to surface hazards
Force explicit answers to “What must never happen?”
Write constraints in plain language before encoding them
Treat unresolved ambiguity as a blocker, not a footnote
You may proceed only if:
The domain can be explained without mentioning the agent
Success and failure are both clearly described
Hazards are named, not implied
Sources of truth are agreed upon
Humans understand where responsibility remains theirs
If not, you are not in Phase 1. You are simply rehearsing failure with better tooling.
Phase 0 feels slow because it is thinking made visible. But every agent that behaves well under pressure — every system that earns trust — was born here, in restraint, clarity, and humility.
Before the agent, there must be a world. Before autonomy, there must be understanding. Anything else is theatre.
No posts
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.