Agentic architecture design

An agent only where a step needs one

A workflow that runs with fewer agents to pay for and watch. Which steps get one and what each may touch is settled before you pay for the build.

Book a free consultation See client results
30+ production deployments since 2017
Why agent architectures age badly

Teams pick the pattern before mapping the steps.

The bill comes later: model calls where lookups would do, state in prompts, no approvals.

  1. 01

    Where it stallsOne pattern covers the whole workflow.

    What we do Each step: code, model call, agent or person.

  2. 02

    Where it stallsPermissions get decided mid-build.

    What we do Permissions and approvals designed before any code.

  3. 03

    Where it stallsThe design is judged by the demo.

    What we do Measured per step; rejected options written down.

How we design it

A design your team can defend

Written by the engineers who would build it, on your systems.

  1. 0103

    Every step mapped and assigned

    Rules stay in code, a model classifies, an agent takes open-ended work, costly errors go to a person.

    • Step-by-step workflow map
    • Error cost per step
    • An owner for every step
    44% for a raw LLM, 98% when the guideline sets the disposition, on the open 50-scenario benchmark.
  2. 0203

    The trade-offs, written down

    Every choice is recorded with the options it beat, so your team can defend it.

    • Decision record with trade-offs
    • A reference design
    • Model and cost per step
  3. 0303

    Testable from sprint one

    An evaluation plan sets test cases, metrics and thresholds per step, and every sprint is measured against it.

    • Model you can swap
    • Design files in your repository
    • Evaluation plan per step
Engineering in the open

We help build what agentic AI runs on

Open standards, open-source tooling and published research, all public, so you can check our engineering before you hire us.

Shaping agentic AI

The first agentic AI engineering company to join the Agentic AI Foundation

The Linux Foundation formed it around Anthropic's MCP, OpenAI's AGENTS.md and Block's goose. AWS, Google and Microsoft are platinum members. In its own words: “Together, we're shaping the future of agentic AI.”

Open source

We build open-source agent tooling that other engineering teams install

9M+ PyPI downloads
3,900+ GitHub stars
31 public repositories

Framework contributors

When the framework breaks, we fix it at the source

We maintain our own open-source agent framework and contribute fixes to the frameworks our agents run on, through official partnerships with their teams. Breaking changes reach us before they reach your codebase.

Research

Our engineers and PhDs publish peer-reviewed research

Peer-reviewed papers on agent architectures, evaluation and AI security, and an open benchmark anyone can rerun against our results.

Track record

Frontier AI teams now build on what we shipped first

Our client agents were in production before most of today's agent frameworks had a stable release. You get a team that already knows what breaks between a promising demo and a system people rely on every day.

Case studies
All case studies
Engagement models

Ways to start

Each path starts with a free call with a founder or senior AI engineer. A build goes ahead only after its Proof of Value meets the agreed threshold.

Start with one workflow

We map one workflow with your experts and agree a success threshold before any build.

Best whenYou want the success test agreed before you commit to a build.

Book a free consultation
  1. Design and build Best whenArchitecture and build from one team.
  2. Engineering-led advisory Best whenNot sure which workflow should get an agent.
  3. Stalled pilot recovery Best whenThe agent exists, and its architecture is the problem.
Technology

What the design chooses between

Picked per step and recorded, with the model kept replaceable.

  1. Model Per step, replaceable, hosted or self-hosted
  2. Pattern One agent, several or fixed workflow
  3. Orchestration Typed loops, graphs or fixed flows
  4. Retrieval and state Indexes, run state, memory stores
    • RAG
    • Qdrant
    • pgvector
    • PostgreSQL
    • Redis
  5. Your environment Your VPC or approved cloud
    • Self-hosted
    • Your cloud

How we choose the stack

FAQ

Questions about agentic architecture design

What is agentic architecture design? +
It is the set of decisions made before an agent system is built. They cover which steps run as code, model calls, agents or people, how the agents are orchestrated, where retrieval fits, how tools are typed and permissioned, what state the system keeps and which model runs each step. The output is a decision record, a reference design and an evaluation plan.
What does agentic architecture design include? +
A step-by-step map of one workflow, with the cost of an error at each step. Every step then gets a decision: plain code, a model call, an agent or a person. The design then settles orchestration, retrieval, tool permissions, state, memory, human checkpoints and the model per step, with expected cost and latency. You get a decision record, a reference design and an evaluation plan with metrics per step. The build can follow as a separate phase.
Should we use one agent or several? +
Start from the work. One agent with a small set of tools is easier to test and cheaper to run. Several agents make sense when the work splits into roles that need different tools, permissions or models. Many workflows are better served by a fixed workflow that calls a model at two or three steps.
When is a deterministic workflow better than an agent? +
When the order of steps is known and the rules do not change. Code is cheaper, faster and easier to audit than a model choosing the next step. An agent earns its place where the next step depends on what the system finds, such as an unfamiliar document or an exception the rules do not cover.
Do you design around one framework or model provider? +
No. The design names the framework and the model that fit each step and keeps the model replaceable. The decision record explains every framework choice, so your team can revisit it later.
What do we get at the end of the design? +
An architecture decision record with the options considered and why each one won or lost. Alongside it, a reference design with components, data flow and tool contracts, and an evaluation plan with test cases and thresholds per step. All three go into your repository.
Can you review an architecture we already run? +
Yes. We map the system as it runs, compare it with what the workflow needs and list the changes in order of cost and effect. If the system is struggling in daily use, an AI agent audit covers the same ground and adds a fix plan.
Who builds the system after the design? +
Your team, ours, or both together. The design is written so another team can build from it. When we build it, the engineers who wrote the design do the work.
Design review

Bring one workflow to a design review

We split it into steps and show where an agent pays off.

Book a free consultationRead case studies
From the blog

Reading on agent architecture

All articles
Agentic AI

Single agent vs multi-agent systems: when one agent is not enough

One agent or several? Deterministic orchestration beats both when the flow is predictable. Pros, cons and the architectures, with production examples.
Agentic AI

Building Production-Grade AI Agents: How We Brought Deep Agent Patterns to Pydantic

Vstorm delivered pydantic-deep - a comprehensive framework for building "deep agents" that can operate in isolated environments.
Engineering

Agentic RAG: Architecture, Knowledge, Access Control

How agentic RAG changes architecture, knowledge and access control: corrective vs self-reflective designs, what they cost, and where permission checks belong.