Humans Think, AI Does the Rest — Coordinating AI Agents with a Knowledge Graph

Humans Think, AI Does the Rest — Coordinating AI Agents with a Knowledge Graph

One AI assistant is easy. A team of agents working in parallel needs something more: a shared record that every agent and every person reads and writes. This 1-hour live session shows how a knowledge graph becomes that record — so people stay at the conceptual level and the agents do the rest. We show it on our own delivery, with an open template you can fork and use yourself.

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 help for a while, then decay. What works is a shared record that:

• every participant, human or agent, reads and writes,
• knows the difference between a concept, a plan, a decision and a verdict,
• and can answer "what is still waiting for a review?" without anyone reading through everything.

Why a knowledge graph

A knowledge graph holds exactly that: typed things — concepts, work items, decisions, tests, results — and the relationships between them. Agents connect to it over MCP, take their instructions from it and write their results back. Questions that would otherwise mean an afternoon with tickets, chat histories and log files become a walk across the graph: what did this release fix, and what did it break? Which decisions does this change depend on? Where does a person still need to look?

Documents and retrieval still provide the depth. The graph provides the connected picture that lets many agents work on the same thing without a human relaying context between them.

Two properties carry most of the discipline:

• a gate on every work item — one line naming the condition that closes it, checkable by someone who did not do the work;
• a review budget (none, glance or judgment) — decided when the work is planned, so human attention goes where it matters and nowhere else.

A worked example: how we build our own product

We run this pattern on the development of our own platform, Metapad. Since January we have built more than 330 versions — 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. We wrote the story up on our blog.

The structure behind it is open as a template: Delivery OS — phases, concepts and implementation plans; work items and releases; test scenarios, tests and test runs. It is not tied to software: at transentis we use the same pattern to create content, to build enterprise models and digital twins, and to manage bids and projects.

Try it before you come. Delivery OS is public — open it here. Its description is the full guide, and a small demo project (an event-ticketing app) shows every type in use. Fork it and connect your own AI assistant over MCP; nothing to prepare, but if you arrive with a question from your own work, so much the better.

Agenda

• 5 min — Two levels of work. Where people add the most and AI the least, where AI is now faster and more thorough than we are, and the one arrow back up.
• 10 min — Why agents need a shared record. What breaks when agents work in parallel, and what a knowledge graph needs to hold to fix it: concepts, decisions, work items, verdicts — plus gates and review budgets.
• 25 min — A release, live. On a fork of Delivery OS, with an AI agent connected over MCP: an idea becomes a concept, the concept becomes work items with gates and review budgets, the work items are planned into a release, a review runs as a gallery, and a regression run is recorded with what it fixed and broke. The audience chooses what we plan.
• 10 min — Beyond software. One graph per project, forked from one template, and agents working across several graphs — for content, enterprise models, bids and projects. The pattern fits many teams that deliver change.
• 10 min — Q&A and what's next. Your questions on the pattern, the graph and the agents — and what it takes to set this up for your own team.

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.
• AI practitioners building with Claude Code, MCP or other agent tooling, who want a working example of agents sharing one record.
• 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.
• Modelling practitioners — enterprise architects, business engineers, knowledge engineers — who want to see a delivery process modelled as a computational knowledge graph.

What you'll take away

• A pattern for coordinating agents — what a shared record needs to hold so that several agents and people can work on the same thing.
• A clear line between the levels — what people should keep doing, and what can be handed to agents today.
• The human-attention budget — why the bottleneck is often not the AI but the person reviewing it, and how to plan for that release by release.
• An open template and a first step — Delivery OS to fork, and a concrete idea of which project to start with and how to connect your agents.

Practical

• Duration: 1 hour
• Format: Virtual (Zoom — link sent on registration)
• Cost: Free
• Dates:
  • English — Thursday, 10 December 2026, 16:00 CET
• What to bring: a piece of work your team delivers that you would like to see planned this way. We will take suggestions from the audience and plan one live.

Your Host

Dr. Oliver Grasl — Founder & Managing Partner at transentis

Oliver has spent over 25 years in enterprise transformation, bringing business engineering, operations research and analytics to bear on how enterprises actually run. He is the architect of Metapad — and the one person at the conceptual level in the process this session describes.

His passion is building models that bring human intelligence and machine intelligence together — computational knowledge graphs that turn complexity into clarity and make change steerable. Running his own team's delivery on one is the most direct test of that idea he knows.