Agentic Engineering

From One Agent to a fully Autonomous System

Software teams are learning to hand whole units of work to autonomous agents. Not just to autocomplete a line, but to take an issue and return a reviewed, merged change. Doing that reliably is less a modelling problem than a systems problem: how work is coordinated, how context is preserved, how correctness is proven, and how humans retain control of a process they no longer supervise step by step.

This book starts with a single agent and the craft of making it useful. It then adds reliability, knowledge, delivery processes, coordination, and feedback until that agent becomes part of a complete autonomous delivery system. The destination is an agentic software development factory. The main chapters form a continuous walkthrough. Optional deep dives let you examine a topic in detail without interrupting that path.

Start with the Preface to understand the book’s scope, or read the Introduction for the complete argument in one chapter. If you would rather explore than read in order, the connections graph beside each chapter shows how it relates to the rest of the system.

---

Contents

Framing

• Preface - Who this book is for, and the two ways to read it.
• Introduction - The destination in one pass, including where the design is still uncertain.
• Prior Art & Lessons - The external projects, books, and research this book draws on, and how they are used.

Part I: One Agent

The working unit everything else is built from.

• Part Overview - Why the walkthrough starts here.
• What an Agent Is - The model, harness, and five design levers.
• Structuring Agent Instructions - Purpose, behaviour, constraints, output, and stopping conditions.
• What Prompt Research Supports - Evidence on instruction style, specificity, personas, reasoning traces, and ordering.
• Managing Prompts as Software - Versioning, evaluation, composition, and governed change.
• Working With Probabilistic Models - Variance, compound error, and predictable limitations.
• Choosing a Model - Task fit, private evaluation, cost, and operational stability.
• Designing Agent Tools - Small, unambiguous, structurally safe action interfaces.
• Controlling Tool Access - Role boundaries, approval gates, and audit records.
• Packaging Agent Capabilities - When to use tools, skills, or MCP servers.
• Common Agent Failure Patterns - Seven ways an overloaded or underspecified environment weakens an agent.
• The Agent Loop - The bounded think-act-observe cycle.
• Autonomous Outer Loops - Fresh sessions, durable state, and machine-verifiable completion.

Deep dives: Foundational AI Model · MCP

Part II: A Reliable Agent

Engineering the environment so failure becomes structurally hard.

• The Harness - The execution loop and the machinery around the model.
• Durable Agent Execution - Replay, suspension, retry-safe side effects, and recovery for long-running agents.
• The Agent-Computer Interface - The tool surface, where much of an agent’s capability lives.
• Verification & the Outer Loop - Why agents declare success early, and how to catch them.
• Controls & Autonomy - The autonomy ladder, risk tiers, and approval gates.
• Security & Prompt Injection - The lethal trifecta, and why only structural controls hold.

Deep dives: Guardrails · ACRI

Part III: What the Agent Knows

Context and knowledge decide output quality before the first token.

• Context - Everything an agent knows at the moment it acts, and how to keep it dense.
• The Knowledge Base - The retrieval-reasoning spectrum, and why agentic search beats RAG for code.
• Skills - Packaged procedural knowledge and progressive disclosure.
• Agent Readiness - Building an environment where telling the agent is unnecessary, and ratcheting legacy codebases there.

Deep dives: Context Topics (layers, runtime management, lifecycle, evaluation) · Knowledge Base Topics (spectrum, hybrid architecture, routing, adoption) · Skill Format · Skill Gateway

Part IV: Delivering Real Work

The pipeline from a raw issue to a merged change.

• Agentic Software Development - The end-to-end delivery model.
• Ticket Enrichment - Turning a raw issue into workable, well-scoped context.
• Planning & Execution - The plan as the cheap checkpoint, and test-first validation.
• End-to-End Orchestration - The issue-to-pull-request pipeline across systems.

Deep dives: Execution · Orchestration Triggers · Model Usage · Smart Routing · Collaborative Development Structure · Economics & Routing · Execution & Feedback · Operations & Governance

Part V: Many Agents

Scaling the unit into a coordinated system.

• The Agentic Swarm - The target system: many agents working as one pipeline.
• The Coordination Model - The rule that keeps them safe: reads parallelise, writes do not.
• Agent-to-Agent Protocols - The interoperability landscape: A2A, ACP, ANP, and the older standards behind them.
• Agent · Agent Pool · Cohort · Orchestrator - The runtime primitives.
• Agent Architecture - Runtime components and deployment modes.
• Swarm Operations - Running a fleet in production: watchdogs, merge queues, identity, and economics.

Deep dives: The Execution Ledger

Part VI: Continuous Learning

Closing the feedback loop without allowing production mistakes to become permanent behaviour.

• Self-Learning Agents - Capturing agent traces and user corrections, then promoting proven lessons into context, harnesses, or model weights.
• The Evaluation Harness - Measuring the system against a private, contamination-resistant corpus.

Deep dive: Skill Evaluation

Part VII: The Software Dark Factory

Turning a learning agent system into a continuously operating software-production capability.

• Software Dark Factory - The operating model, factory loop, entry conditions, and boundary of autonomous software production.
• The Minimal Bootstrap - The threshold at which the system can improve itself.
• Architecture - How software-factory components are deployed and isolated.

Deep dives: Minimal Goals · Harness Requirements

Part VIII: The Autonomous Business Unit

Giving the factory a durable business identity and the wider world signals required to choose and perform work.

• Autonomous Business Unit - How mission, goals, axioms, authority, capabilities, and external signals become an operational identity for agents.
• Axioms - The hard constitutional invariants installed into a unit to constrain every plan and action.
• System Characteristics - Recommended qualities such as recoverability, flexibility, observability, and progressive operationalization.
• Goals - A composable goal model across five cumulative stages: continuity, business direction, capability building, real-world operation, and continuous optimisation.
• World Signals - The sensor and perception boundary through which the unit receives governed observations.
• Business State Estimation - How uncertain and conflicting observations become a governed model of current conditions.
• Workflow Engine - The durable executive layer that routes state changes into deterministic execution, agent runs, approvals, or fallback.

Deep dives: Defensibility and External Enforcement

Technologies

Named implementations discussed throughout the book, mapped back to the concepts they may support.

• Technology Overview - How to evaluate technologies without confusing an implementation with an architectural responsibility.
• Knowledge Bases: TrustGraph - Controlled knowledge access, context graphs, ontologies, provenance, multimodal ingestion, and lifecycle boundaries.
• Hosting Platforms: Vercel eve - Durable agent sessions, channels, approvals, sandboxes, traces, and evals.
• Agent Interfaces and Protocols: AG-UI - The application-to-agent event protocol and the limits of its responsibility.