# Designing and running agentic systems Thibault Souris · 2026 Edition The target architecture: the decision framework, from language to evaluation, so they hold up in production. > Architecture first, model second. > > Start simple, isolate behind contracts, add complexity only on evidence. ## Author's note For two years, generative AI was experienced as a rupture: we marveled that a machine could write, summarize, code. That time has passed. The question is no longer whether the technology impresses, but how to integrate it for good into processes, professions, and organizations. And there, the verdict is harsh: nearly every application calls itself "agentic," and almost none truly holds up in production. The vast majority of pilot projects fail to make that leap, and always for the same reasons: we do not know how to evaluate nondeterministic behavior, we do not know how to govern it, we cannot say in advance when it will be wrong. These are not model problems. They are architecture problems. "Adopting AI," moreover, covers two realities that are too often confused. Giving teams generative assistants for writing or analysis is a matter of acculturation: useful, but relatively simple and with little structural risk. Integrating agentic systems into processes, existing or yet to be invented, is something else entirely: it means rethinking flows, trust, governance, reliability. It is this second adoption, the harder one, that is at stake here; and the confusion between the two explains a good share of the disillusionment. The sign that the stakes have shifted from the model to integration lies in a decision the largest model providers have just made: rather than ship one more model, they are building deployment organizations and sending engineers to embed with their customers. When those who build the models conclude that the bottleneck is no longer the model but its integration into the real world, the case is closed: the value plays out around the model, not inside it. Too many teams, however, still choose a framework before they have thought through their architecture, and pay for that choice for months. The conviction behind these pages is the exact opposite: it is not the model that dictates the architecture, it is the architecture that frames the model. The model is rented and replaced; the architecture is owned and compounds. Once that reversal is accepted, the rest (language, topology, memory, evaluation, security) ceases to be an initial bet and becomes a sequence of reversible decisions, made behind stable contracts. These pages are addressed to anyone who designs, runs, or defends such systems, and wants to do so on foundations that last. Thibault Souris · 2026 ## Contents ### PART I · The foundations The bedrock: why the architecture frames the model, and how decoupling makes language and topology reversible. - [Section 01 · Framing, how to read, and the guiding principle](https://runward.dev/docs/en/reference/doctrine/01-cadre/) - [Section 02 · The decoupling that makes language and topology secondary](https://runward.dev/docs/en/reference/doctrine/02-decouplage/) - [Section 03 · Language choice, full TypeScript or polyglot](https://runward.dev/docs/en/reference/doctrine/03-langage/) - [Section 04 · Modular monolith or microservices](https://runward.dev/docs/en/reference/doctrine/04-monolithe-microservices/) ### PART II · The execution of an agentic system How the system runs: runtime topology, memory and context engineering, state, concurrency, and asynchronous work. - [Section 05 · Runtime topology of an agentic system](https://runward.dev/docs/en/reference/doctrine/05-topologie-runtime/) - [Section 06 · Memory and context engineering](https://runward.dev/docs/en/reference/doctrine/06-memoire-et-contexte/) - [Section 07 · State, concurrency, and scaling](https://runward.dev/docs/en/reference/doctrine/07-etat-scaling/) - [Section 08 · Asynchronous work and scheduling](https://runward.dev/docs/en/reference/doctrine/08-async-ordonnancement/) ### PART III · Robustness, security, and evaluation Holding up over time: runtime resilience, observability, cost control, security, and behavioral evaluation of agents. - [Section 09 · Execution resilience](https://runward.dev/docs/en/reference/doctrine/09-resilience/) - [Section 10 · Observability and cost control](https://runward.dev/docs/en/reference/doctrine/10-observabilite-cout/) - [Section 11 · Execution security](https://runward.dev/docs/en/reference/doctrine/11-securite/) - [Section 12 · Agent evaluation and testing](https://runward.dev/docs/en/reference/doctrine/12-evaluation-tests/) ### PART IV · Decision and synthesis Deciding: the summary decision matrix, the synthesis of recommendations, the extension to shared building blocks, and evidence in code. - [Section 13 · Summary decision matrix](https://runward.dev/docs/en/reference/doctrine/13-matrice-decision/) - [Section 14 · Synthesis and recommendations](https://runward.dev/docs/en/reference/doctrine/14-synthese/) - [Section 15 · Beyond the application, the shared building blocks](https://runward.dev/docs/en/reference/doctrine/15-briques-partagees/) - [Appendix · Evidence in code](https://runward.dev/docs/en/reference/doctrine/annex-preuves-code/) - [Afterword](https://runward.dev/docs/en/reference/doctrine/postface/) ## Back cover Architecture first, model second. Nearly every application calls itself agentic; almost none holds up in production. The gap is not a model problem, it is an architecture problem. These pages lay out the decision framework that makes the difference: where to draw the boundaries, how to make language and topology reversible, how to keep state explicit, govern memory, secure untrusted inputs, and evaluate nondeterministic behavior. From the first port laid down on day zero to the loop that watches for drift, each section turns an initial bet into a reversible decision, made behind stable contracts. The model remains what it must be: a component you replace, down to its paradigm, while the architecture compounds. For anyone who designs, runs, or defends such systems, and wants to do so on foundations that last. --- © Thibault Souris, 2026 · Creative Commons BY-ND 4.0 (https://creativecommons.org/licenses/by-nd/4.0/) · the work’s text unaltered, as plain text for this page; the PDF version is the reference: https://runward.dev/docs/en/reference/doctrine/Designing-and-Running-Agentic-Systems-2026.pdf