Preface

This is a design book about building a system that writes software on its own. Not a code assistant that finishes your sentence, but a coordinated set of agents that takes an issue, plans an approach, implements it, proves it works, and opens a pull request. A human reviews the plan going in and the change coming out, and very little in between.

We call this ideal system Ikidna: Kiberon Labs’ own concept for a future software development factory. This book is its design record: the architecture, the reasoning behind each decision, and the places where the honest answer is still “we don’t know yet.”

Who this is for

The book assumes you build software and are comfortable with the shape of modern development (issues, pull requests, CI, code review) and with the broad idea of large language models used as agents. It does not assume you have built an agentic system before. Specialised terms are defined where they first appear.

You will get the most from it if you are an engineer or technical lead evaluating whether to build this kind of system, or building one already and looking for a coherent set of decisions to argue with. Much of what follows is contested in the field, we say so where it is, and give our reasons for landing where we did.

How it is organised

• Part I: One Agent is the on-ramp: what an agent actually is, and the craft of prompts, models, tools, and the loop that drives them. Experienced practitioners can skim it for the cited research findings and rejoin at Part II.
• Part II: A Reliable Agent is where engineering starts: the harness, the tool interface, verification, controls, and security. The theme is structural: make failure hard, not discouraged.
• Part III: What the Agent Knows covers context, knowledge, skills, and making a codebase agent-ready. Output quality is decided here before the first token is generated.
• Part IV: Delivering Real Work is the pipeline from a raw issue to a merged change: enrichment, planning, execution, orchestration.
• Part V: Many Agents scales the unit into a coordinated swarm, and covers what running one in production actually takes.
• Part VI: The Self-Improving System is the destination: evaluation, the minimal bootstrap, and Ikidna’s own architecture.

An appendix catalogues the concrete software stack under evaluation for each layer.

Two ways to read it

Read it in order and it works as a book: each part builds on the one before, and the Introduction gives you the argument in miniature before you commit to the whole.

Read it as a reference and it works too. Every chapter is written to stand on its own and links to the others it depends on, so you can enter anywhere and follow the threads. The connections graph in the sidebar makes those threads visible, a fast way to see the neighbourhood of any idea.

A note for non-human readers: this book is also published as plain Markdown. Every chapter is available at its own .md address, and a machine-readable index lives at /llms.txt, so an agent can crawl the same content you are reading now.

With that, turn to the Introduction for the destination, or begin the walkthrough at What an Agent Is. Readers who already run agents in production can jump to The Agentic Swarm, where the system design begins.