Zum Inhalt springen

Details

Running Delivery with AI Agents on a Knowledge Graph

A 1-hour live session on how we deliver Metapad: one person works at the conceptual level — what to build, why, and what was decided — and AI agents do the rest. We walk through the whole process on Delivery OS, the open model behind it, and show what it takes to run your own delivery the same way.

Since January we have built more than 330 versions of Metapad — more than one per calendar day, each followed by a full regression run. AI agents write the work items, the code and the tests, merge, build, triage the regression run and write the documentation, several of them at a time.

A person comes back down into the detail only where it was decided in advance that a person needs to look.

That sounds like a story about AI. It turned out to be a story about something else: keeping everyone, human and machine, working from the same picture.

The problem with more than one agent

One AI assistant in one conversation is easy: you both see the same history. Run three in parallel and that shared history is gone. One agent does not know what another changed an hour ago; tomorrow's agent does not know what was decided today. The person in the middle becomes a message bus, repeating context from one window to the next — the opposite of working at the conceptual level.

Longer prompts and shared notes files decay. What works is a shared record that every participant reads and writes, that knows the difference between a concept, a plan, a decision and a verdict, and that can answer "what is still waiting for a review?" without anyone reading through everything.

The shared record is a knowledge graph

We keep the knowledge graph in a Metapad model, and we have turned its structure into an open template: Delivery OS.

It holds:

  • Phases, Concepts and implementation plans — the conceptual level, where people work with AI as a conversation partner.
  • Issues and releases — every work item ships in a release; before the build that is the plan, after it the release manifest.
  • Test scenarios, tests and test runs — so "what did this release fix, and what did it break?" is a walk across the graph, not an afternoon with log files.

We use this template for any kind of delivery work - software, slides, presentations, proposals, concepts ...

In this event, we will walk through the process and demonstrate it in action.

Who it's for

  • CTOs, engineering leads and heads of product who are adding AI agents to their teams and want them to work as colleagues, not as tools that need a human to relay context.
  • Delivery managers, product owners and PMO leads who want to see what is planned, done and waiting for whom in one picture, rather than across a ticket tool, a CI dashboard and a chat history.
  • Transformation Owners and Operating Model Owners whose "delivery" is not software at all, and who want to see how the pattern carries over.
  • AI practitioners building with Claude Code, MCP or other agent tooling, who want a working example of agents sharing one record.

What you'll take away

  • A clear line between the levels — what people should keep doing, and what can be handed to agents today.
  • A working knowledge of Delivery OS: the types, the gates, the review budgets, and how agents use them. The template is open, so you can fork it afterwards.
  • The human-attention budget — why the bottleneck is not the AI but the person reviewing it, and how to plan for that release by release.
  • A concrete first step for your own team: which project to fork the model for, and how to connect your agents.

Das könnte dir auch gefallen