Build: bring decisions into daily work
Role of the Company Brain: Give people and connected agents the relevant context. Show where tasks and documents still follow old instructions.
For CEOs and leadership teams who want to see whether decisions land in tickets, code and documents. The deep dive is for product and engineering leaders whose teams ship with AI agents.

Build is the third phase: decisions reach the daily work of people and AI agents. The Company Brain gives teams and connected agents the relevant context and shows where tickets, code and documents still follow old instructions. The result is work that follows the approved version and moves on into Operate.
Build is the third phase. It brings decisions into the daily work of people and AI agents.
Input is the decision from Define. The Company Brain gives teams and connected agents the relevant context and shows where tickets, code and documents still follow old instructions. Output is work that follows the approved version; it moves on into Operate.
The deep dive below shows how product and tech teams ship with coding agents without giving up control.
Tickets, roadmaps and agents still work from the old version.
Take the decision into the systems where work happens and show deviations in Jira, code and documents.
Teams and AI agents work from the same approved version.
At the centre: the Company Brain
Every phase draws on the Company Brain and adds new knowledge. The guide explains what it is, who owns it and how quality holds.
Leadership questions in this phase
Answered in the Company Brain guide.
- How do people and AI agents access the Company Brain?
- How does quality stay high when AI agents rely on it?
- What belongs in the first 30 days?
Deep dive for product and tech teams
From code assistance to agentic AI: four levels
Coding tools evolved in four levels. Chat assistants generate snippets on request. Inline copilots complete code in the editor. Autonomous agents such as Claude Code or Cursor read project files, run bash commands and create pull requests. Orchestrated agent systems distribute work across specialised roles with documented handovers. Each level increases autonomy – and with it the price of an unclear brief.
For product managers, level three is the turning point: from here on, the machine executes for hours what you defined. An agent building in the wrong direction for an hour because the goal was unclear produces an hour of damage. The table below maps the levels and the human's role in each.
| Level | What the system does | The human's role |
|---|---|---|
| 1 · Chat assistant | Generates code snippets on request | Writes, reviews and integrates every suggestion personally |
| 2 · Inline copilot | Completes code directly in the editor | Accepts or rejects suggestions in the flow |
| 3 · Autonomous agent | Reads project files, runs commands, creates pull requests | Defines the spec, reviews results, sets the gate |
| 4 · Orchestrated agents | Specialised agents work with documented handovers | Orchestrates roles, standards and the audit trail |
Why classic Scrum breaks in AI development
Scrum assumes work can be cut into plannable increments: story in, estimate attached, done by sprint end. Model training and fine-tuning don't comply – they require unpredictable iteration cycles in which an experiment may fail without the sprint failing. Squeeze AI work into classic stories and you get either burst sprints or estimates nobody takes seriously any more.
The answer is not less discipline but an adapted one: spikes instead of stories for experiments, evaluation criteria in the definition of done, delivering and learning cleanly separated. Frameworks like CRISP-ML(Q) give this structure. The deep dive “Agile for AI: sprints that survive model training” shows the adaptations in detail – without sacrificing delivery discipline.
Live status instead of sprint-end surprises
In classic agile processes the true state of an implementation often becomes visible only at sprint end, and estimates rest on historical experience that can deviate widely from the current source code. A live status inverts this: real-time progress with context on the actual code, estimates grounded in the codebase, dependencies and architectural hurdles surfacing as they arise – not in the review.
Control stays with the team: developers delegate clearly scoped tasks to agents that build against the spec from the define phase, and intervene immediately on deviations. The result is a controlled delivery of reviewed software – without nasty surprises at sprint end.
The ticket becomes the prompt: writing requirements for agents
A Jira ticket in agentic engineering is no longer a work instruction for humans but a context-complete prompt parsed by AI agents. The 100-word pointer “as discussed, see meeting” doesn't work when the addressee wasn't in the meeting. The ticket operationalises the spec from the define phase: goal, context, acceptance criteria, edge cases – complete enough that an agent can build without follow-up questions.
What this anatomy looks like in detail – including story files and context engineering – is covered in “The anatomy of a Jira ticket for AI product management”. The vocabulary behind it, from epic to cycle, is in the product management glossary.
Model Context Protocol: connecting agents to tools
The Model Context Protocol (MCP) is the open standard through which language models communicate directly with tools such as Jira, Slack or local databases. It eliminates the error-prone manual export-import cycles: instead of copying tickets and pasting results back, the agent reads and writes itself – with defined permissions.
For the build phase, MCP is the lever that makes agentic execution practical: the agent fetches the context it needs from the systems where it lives. For product managers this also means: permissions, data access and audit belong in the spec – who may read what, write what, and never touch what.
The sandwich architecture: deterministic cages for probabilistic systems
Autonomous agents in enterprise use need security architecture, not hope. The sandwich architecture flanks the core model with two control layers: an input guardrail checks every input for prompt injections and accidentally transmitted personal data before it reaches the core model. An output guardrail verifies the response – against hallucinations, against disclosure of confidential system information, against violations of your own policies.
The principle behind it: never trust the model blindly. It is not a safe internal logic component but a system that can interpret any input as an instruction. High-stakes decisions therefore stay with classic code or with humans; regular attack simulations by your own team expose weaknesses before others do.
Security costs latency – every control layer takes time. That trade-off is a product decision, not a technical one: it belongs in the PRD, with thresholds per use case.
PM, data scientist, ML engineer: handovers decide
Empirically, AI features rarely fail on model architecture – they fail on poor handovers, where responsibilities blur between product management, data science and engineering. The build phase is where this friction becomes visible: who defines the evaluation criteria? Who decides when a model is good enough? Who carries the pager when it drifts?
“PM, data scientist, ML engineer: who does what?” delivers the role boundaries that work – and the two launch questions every AI team must answer in writing. The short version: every handover needs an artefact, and every artefact needs an owner.
Autonomy needs standards: the Spotify trap
The Spotify model promises autonomous squads shipping independently. With AI agents, this autonomy without central standards turns into architectural chaos: every team prompts differently, every codebase diverges faster, and token budgets burn in redundant work. Agents scale the effect of every decision – including the bad ones.
Organised alignment is therefore mandatory: shared spec standards, shared context files, central guardrails. “Why the Spotify model fails – even more so with AI agents” draws the lessons from the documented cases – as a warning against boundless agility in the AI era.
Deep dives for this phase
Each article answers a concrete question from the practice of product and tech teams.
Agile for AI: sprints that survive model training
Spikes instead of stories, eval in the definition of done – delivering and learning cleanly separated.
Read post Focus: Jira ticket AI product managementThe anatomy of a Jira ticket for AI product management
From a 100-word pointer to a context-complete prompt – the four phases, BMAD story files and context engineering.
Read post Focus: AI product team structurePM, data scientist, ML engineer: who does what?
Role boundaries that work – and the two launch questions every AI team must answer in writing.
Read post Focus: Spotify model product managementWhy the Spotify model fails – even more so with AI agents
Squads, tribes and the lessons of their failure – updated for teams whose most autonomous member is an AI.
Read post Focus: Graph engineering AI agentsGraph engineering: multi-agent workflows, not chat chains
When a multi-agent graph beats a single loop – with numbers from Anthropic and the counter-position from Cognition.
Read post Focus: Claude Code für Product ManagerClaude Code for product managers: the setup that holds
Context files, plan mode, ticket scope, two-layer review, routines and permissions – the setup step by step.
Read post Focus: PM to engineer ratioPM to engineer ratio: PMs on problems, not teams
Why the pod formula is an HR convention – and how Whatnot scales with few, senior PMs. With Tom Verrilli from Lenny's Podcast.
Read post Focus: agentic loopsAgentic loops: from prompting to a multiplayer team of agents
The six stages of AI work in software engineering, the goal card for tasks without a compiler, and why the next stage is multiplayer.
Read post Focus: AI product operating modelAI product operating model: from managing work to managing context
Seven patterns from more than thirty interviews with the teams behind Claude Code, Codex and Cursor, and the one shift underneath: shared context instead of coding capacity.
Read postMatching Activities from the Playbook
From the article straight into practice: these Activities put the concepts to work with Teklens.
Frequently asked questions
What is agentic AI execution?
The use of autonomous AI agents that don't just suggest code but read project files, run commands and create pull requests – against a spec agreed up front. The human defines and reviews, the machine executes. The more autonomous the agent, the more precise briefs and guardrails matter.
Does Scrum still work for AI products?
Yes, with adaptations: spikes instead of stories for experiments, evaluation criteria in the definition of done, delivering and learning separated. What no longer works is the assumption that effort and outcome correlate predictably – model training doesn't respect sprint boundaries.
What is the Model Context Protocol (MCP)?
An open standard through which language models communicate directly with tools such as Jira, Slack or databases. MCP replaces manual export-import cycles with defined interfaces and permissions – the agent fetches context itself instead of having it pasted in.
How do I secure autonomous agents in the enterprise?
With a sandwich architecture: an input guardrail against prompt injections and PII violations, the core model for the logic, an output guardrail against hallucinations and data leakage. Plus: keep high-stakes decisions with classic code or humans, and simulate attacks on yourself regularly. The latency cost belongs in the PRD as an explicit trade-off.
Next phase in the cycle
From Build to Operate: delivered work goes in, results and lessons come out. The Company Brain records what became of the decision.
Phase 04 · Operate – Operate


No new piece without you.
New articles, new interactive tools, new evidence – in your inbox first. And when you reply, we reply: you write directly with the authors, not with a no-reply.
No spam, no sharing, unsubscribe any time.
Bring one important decision.
Discovery Call: 30 minutes with a founder. Bring an important decision or a concrete context problem.
With a founder. No obligation.