Agentic Engineering

From One Agent to an Autonomous Software Delivery System

Software teams are learning to hand whole units of work to autonomous agents. Not 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 kept alive, how correctness is proven, and how a human stays in control of a process that mostly runs without one.

This book walks that road from the beginning. It starts with a single agent and the craft of making it work, climbs through reliability, knowledge, and delivery process, and ends at the system this book exists to design: Ikidna, Kiberon Labs’ concept for a future software development factory, realised as an agentic swarm for autonomous delivery. The main chapters focus on a walkthrough from basic to advanced usage, as well as deep-dive side chapters for readers who want the full treatment of a topic before moving on. It is opinionated where the evidence supports an opinion and honest where it does not.

Start with the Preface for how to read it, or the Introduction for the destination in one sitting. If you would rather explore than read in order, the connections graph in each chapter’s sidebar shows how it links to the rest.

---

Contents

Front Matter

• Preface - Who this book is for, and the two ways to read it.
• Introduction - The destination in one pass: what Ikidna is, and where it 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 - A model plus a harness, the five levers, and the seven early mistakes.
• Instructing an Agent - Prompt structure, the language research that replicates, and the maturity ladder.
• Working With Models - Probabilistic behaviour, compound error, the limitations catalogue, and selection.
• Giving an Agent Tools - The action surface: design, description, restriction, and cost.
• The Agent Loop - Think-act-observe, the autonomous outer loop, and the leverage ladder.

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.
• 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: The Self-Improving System

The point of the whole exercise: a system that improves itself, safely.

• The Evaluation Harness - Measuring the system against a private, contamination-resistant corpus.
• The Minimal Bootstrap - The threshold at which the system can improve itself.
• Axioms - The principles the architecture must preserve.
• Goals - The two-phase roadmap.
• Architecture - How Ikidna’s pieces are deployed and isolated.

Deep dives: Minimal Goals · Ikidna Harness Notes · Skill Evaluation

Appendix: The Software Stack

• Stack Overview - The tools actually considered for implementation.
• Harnesses · Models · Model Providers · Context Engines - Reference pages per layer.