Most agent projects fail on what the agent understands about the business, not on model capability. Groundwork maps your operation into a Context Layer, and every agent reasons from it.
Who this is for
Groundwork is for operators who have put agents or automation into production and cannot explain why the output is wrong. The integrations connect. The model is current. The team still reads everything before it goes out.
If you have not deployed anything yet, you do not need this. The problem Groundwork solves only appears once agents are live and reasoning from your systems.
The cost
01
The escalation rate that never fell.
02
The person who reads every agent reply before it sends.
03
Answers that are confidently wrong, and nobody can trace back to a cause.
04
The second and third agent, each of which needed its own integration work.
The failure it fixes
The model is capable. The integrations work. The agent still gets things wrong, because it is reasoning from a pile of API responses rather than an understanding of how your business runs.
Groundwork fixes this at the foundation. Before an agent handles a single conversation, your operation is mapped into a Context Layer that every agent reasons from. This does not make the model better. It makes the model answer from your operation rather than from whatever the last API call returned.
The Context Layer
The Context Layer is a structured account of what things are, how they relate, and what the rules are. Every system you connect is read through it — the data stays where it is — so agents see one coherent picture rather than six disconnected data sources.
It is not a document sitting beside the systems. It is what the agents read, which means where the layer is wrong the agents are wrong, so you read it and correct it before anything runs.
Context Layer
Workflows
How you run, with deterministic policy gates.
Grounding
Attributes, style, policies and escalation.
Integrations
Your systems, mapped onto your ontology.
Ontology
What exists in your business, what it is called, and how it relates.
Ontology, workflows, grounding and integrations — each with its own gates and controls. See how the Context Layer is built.
How it works
Groundwork works as a loop. The first time round, Replay and Map happen with our team — that's Foundations. Every loop after, the product runs all four stages on your own live traffic, and nothing changes without going through Prove. See the full process.
Your business into the product
The product at work
Foundations
What happens
The first Replay and Map, run with your team as a fixed-scope engagement.
What you receive
A Context Layer in your language, an evaluation set built from your own cases, and agents configured and proved against it. It's yours, in your Groundwork account, whatever you decide next.
Duration
1-2 weeks from kickoff. Replay runs in week 1, Map in week 2.
Investment
Fixed on the scope confirmed at the scoping call, not on time spent. You see the number before anything starts.
Placeholder
Where the historical cases sit during Foundations, who has access, what is retained after the engagement, and what is never used — content pending.
FAQs
A capable model reasons well about something it understands. It cannot infer that a booking in one system and a reservation in another are the same object, or which of the two is authoritative when they disagree. The ontology settles that before the model is asked anything.
A structured account of your operation: the concepts the business runs on, how they relate, the workflows that move work through them, and the rules that bound them. Agents read from it rather than from raw system responses.
Judgement, exceptions, and anything your policies mark as human. Escalation is defined in the workflow rather than left to the agent's discretion, and the person picking it up receives the full context of the conversation.
A deterministic check inside a workflow. It passes or it stops, and the agent cannot reason its way around it. Refund limits, identity checks and required wording live here.
You change it. The ontology is a document you own, not a build artefact. Adding a concept, renaming one or tightening a rule is an edit you make and prove against your own history before it reaches production.
Anything reachable through MCP or an HTTP API, and files where there is no API. Each connection is mapped onto the ontology once, and you set which actions agents may take through it.
It runs as a fixed scope of work with dates agreed at the scoping call, not an open engagement. We replay your history, map it, you review and correct, and it ends with a Context Layer you can read.
Your ontology, your workflows, your policies and the evaluation set built from your history. All of it is readable and exportable, in the same form your team reviewed during Map.
Bring a month of real cases. We will map them and show you where your agents have been reasoning without a Context Layer.