Skip to content
runward
runward
Product
Who it is for
Trust
Documentation
News
Try it on an example Talk to us

Docs · The doctrine · Section 01

Framing, how to read, and the guiding principle

The shift from demonstration to execution comes down to an engineering question: how do you run a reliable agentic system without binding yourself to a stack, a vendor, or a topology that will have to be undone later?

The guiding principle, restated

The founding principle is simple: the architecture frames the model, not the other way around. A strong practical consequence follows: language and deployment topology are adapter decisions, made behind stable contracts, not structural commitments made on day one. The business domain, for its part, does not change when the stack changes.

Operational corollary: you do not choose a stack and then an architecture. You first set the boundaries (ports, contracts, integration protocol), which then makes the choice of language and decomposition reversible and local.

What this document covers, and what it does not

Words invite confusion, and confusion is expensive. Artificial intelligence is the entire field. Generative AI is a subset of it: it produces content, and an assistant that drafts or summarizes belongs to it. An agentic system, for its part, does not merely generate: it plans, calls tools, acts in a loop toward a goal, with memory and bounded autonomy. It uses a generative model as a component, but it is defined by its orchestration, not by its generation. At the other end, classical automation, known as RPA, is deterministic and scripted, and therefore brittle at the slightest change.

The blur is real: a fixed pipeline around a single model call is not agentic, it is augmented automation; an agent on fixed rails is close to RPA. Agentics begins with non-deterministic reasoning, tools, autonomy, and memory; between the fixed path and dynamic delegation lies a whole spectrum.

This document addresses the technical architecture of these agentic systems, and their integration into processes, existing or new. It does not address enablement, equipping people with generative assistants: equipping teams is another subject, essential but distinct. What is at stake here is integration into operations, where most projects fail. It likewise sets aside two neighboring and complementary questions: the build-or-buy tradeoff for each layer, and the mapping to specific regulatory texts. These are layers that sit on top, not blind spots: the principles that govern them, shared building blocks, graduated sovereignty, a register of uses, are laid out in Section 15. Their vendor landscape, shifting and dated by nature, is deliberately kept out of these pages: the doctrine targets what holds regardless of vendors and jurisdictions.

One last framing point, an essential one: this document describes the target architecture, complete, the one to move toward, not a prerequisite to build in a single block. The floor of a first system amounts to little: a single orchestrator, a model port, persistence, a few guardrails, and observability. Everything else, fine-grained memory engineering, state externalization, multi-agent, an evaluation loop, is added only when an objective trigger or a measured gain justifies it. The decision matrix (Section 13) and the recommendations by horizon (Section 14) state what is laid down on day zero and what is deferred. The richness of these pages is therefore not complexity imposed from the outset: it is a target to advance toward in stages, each building block justified by evidence.

What is inherited, what is new

The plumbing of this doctrine is not invented here: immutable log and replay, service discovery, compensation, idempotency, suspend and resume are distributed-systems patterns proven over decades. That is a strength: we inherit patterns validated at scale, and we pay the design cost only once, on what is specific to the component. Four things, however, did not exist in classical distributed systems, and justify a doctrine of their own. The core is non-deterministic: a guardrail cannot be a tool the model chooses to call, it is enforced in middleware (Sections 05 and 12). Untrusted input is indistinguishable from instruction: retrieved content is treated as data, never as an order (Section 11). Memory and forgetting become engineering: turning a stateless model into a stateful agent demands explicit consolidation and forgetting (Section 06). And agency carries an unprecedented blast radius: a compromised agent acts fast and irreversibly, hence bounded autonomy and approval on action (Sections 09, 11, and 13).

The questions addressed

Team questionAddressed in
Full TypeScript, or a back end in Python, Rust, or Go?Sections 02 and 03
Monolith or microservices, and when to split?Section 04
How does it actually run, and how does it hold up under load?Sections 05, 07 to 09
How does the agent remember, and forget without betraying itself?Section 06
How do we keep trust: observability, security, evaluation?Sections 10 to 12
And what is shared across several applications?Section 15

The assumptions adopted

  • An agentic system that is useful in production is first a matter of architecture around the model, not of framework.
  • The best systems use simple, composable patterns, and add complexity only when it genuinely improves the result.
  • Every heavy decision must remain reversible, because it is isolated behind a contract.

Talk to us

Tell us who you are, and we will get back to you.

Your details are recorded by Another Framework, publisher of runward, to get back to you. They are neither sold nor shared, and are deleted three years after our last exchange. To see or delete them: contact@runward.dev.