Resolve the schema for this document type
An invoice resolves invoice fields. A contract resolves clause fields. Neither carries the other's schema.
← All use cases
Use case 16 of 28
AI Document Processing
ingest → extract → validate → post
Invoices, contracts and forms arrive by the thousand. Each page is processed with the same extraction schema, the same validation rules and the same counterparty quirks attached — the constant is sent per page, the value is produced per document.
Where the spend goes
The same knowledge, paid for at every step.
This is the shape of the problem in AI document processing: a pipeline where each step re-establishes context the previous step already had.
Recurring context by stepTypical pattern
ingestdocument type rules, routing policy
extractionfull extraction schema, per page
validationall validation and tolerance rules
postingcounterparty rules, account mapping
What we do here
How ensemble helps in AI document processing.
Attach quirks to counterparties
How a particular vendor formats its documents becomes a fact on that vendor, resolved only when their documents are processed.
Make validation a rule set
Tolerances and matching rules become policy objects, so failures are explainable and consistent instead of model-dependent.
Learn from corrections
Every human correction becomes a fact that narrows what the next document of that type has to be told.
The context each agent gets
These are the dimensions your agents resolve against.
Each one is a set of objects with relations, not a section of a prompt. An agent asks for what its task needs and receives that much.
- Document types
- Extraction schemas
- Validation rules
- Counterparties
- Account mappings
- Correction history
The layer underneath
Business logic as objects, not as prose.
Most AI products keep business knowledge as prompt text — long strings pasted in front of every call. Text has no structure, so nothing can be selected out of it. The only available move is to send all of it, every time. ensemble models the same knowledge as objects with typed attributes and explicit relations, and objects can be queried.
Today
A prompt preamble
Everything the agent might need, concatenated and re-sent. It cannot be narrowed, because there is nothing in a paragraph to select on. Cost grows with how much your business knows.
With ensemble
A resolved context
Exactly the objects this agent needs for this task, assembled at call time. Cost grows with the complexity of the task, which is the thing your customer is actually paying for.
Domain
What the thing is — a product, an account, a campaign, a policy, a prior decision.
Scope
Who it belongs to — this tenant, this customer, this department, or everyone.
Time
When it was true, what superseded it, and which version applied at the moment in question.
Confidence
Validated fact, inference, or unverified claim — so an agent knows what it is standing on.
Purpose
Which kind of task the fact is actually useful for. Most knowledge is irrelevant to most tasks.
Multidimensional means every object carries those five axes at once, and a request resolves along all of them. In AI document processing, that is the difference between sending the whole business and sending 6 kinds of fact, filtered to the task in front of the agent.
How it integrates
One call replaces the block of text you assemble today.
No model change, no framework migration, no rewrite of your agents. The only thing that changes is where the context comes from.
Step 01
Audit
You send 100 production runs. We measure token usage per agent, how much of it is repeated business knowledge, and what a completed task costs today. Read-only — nothing is integrated yet.
No integration · Free
Step 02
Model
We build the object model of your business logic from what you already have — databases, documents, existing prompts and the production runs themselves. This is where the pipeline below earns its keep.
Weeks, not quarters
Step 03
Route
Replace the place where your agents assemble context with one resolve call. Run it side by side with your current prompt first — same outputs, fewer tokens — then cut over.
Shadow mode first
Your agent, after — AI document processing
const context = await ensemble.resolve({
agent: "extractor",
task: "extract_fields",
subject: { doctype: invoice },
});
// context.block is the resolved business knowledge —
// typically a fraction of what you send today.
const answer = await model.complete({
system: context.block,
messages,
});
// every resolution is metered
context.usage; // { tokensIn, baseline, saved }Provider-agnosticWorks with the models you already run. ensemble assembles the context; it does not sit in the inference path unless you want it to.
Measured, not claimedEvery resolution logs tokens against the baseline your prompt would have sent, so the saving is a number in your dashboard.
Your data stays yoursThe object model is yours. It can run inside your perimeter, and it can be exported.
Who builds it
Modelling business logic is the hard part. It is also what we have been doing for 25 years.
25+
Years building complex systems where the business logic — not the interface — was the product
Structuring a company's knowledge into objects that an agent can query is not a prompt-engineering exercise. It is domain modelling, and doing it by hand is why most teams never get past a prompt preamble.
We built an automated pipeline for it. It reads a product — its code, its data, its documents and its actual production runs — and produces a visual model of the business logic inside: the entities, the rules, the relations and the places where agents are re-deriving something the system already knows.
That model is the deliverable you can look at and argue with, and it is also the thing your agents resolve against. Both come out of the same pipeline, which is why the timeline is weeks rather than a consulting engagement.
What the pipeline produces
01A map of your product's business logic, drawn from its own code and data
02The entities, rules and relations your agents actually depend on
03Agent-by-agent cost attribution against that map
04The context routing rules that follow from it, ready to run