Model the checklist as obligations
Each diligence item becomes an object with its evidence requirements, so a document resolves the items it can satisfy.
← All use cases
Use case 26 of 28
AI Due Diligence
dataroom → risk → finding → memo
Diligence is thousands of documents assessed against one framework. The checklist, the risk taxonomy and the findings already confirmed are re-sent per document, so the cost scales with the dataroom rather than with the risk in it.
Where the spend goes
The same knowledge, paid for at every step.
This is the shape of the problem in AI due diligence: a pipeline where each step re-establishes context the previous step already had.
Recurring context by stepTypical pattern
dataroom sweepchecklist, document taxonomy
risk assessmentfull risk framework, per document
finding captureprior findings in full
memoframework and every finding again
What we do here
How ensemble helps in AI due diligence.
Make findings cumulative
A confirmed finding becomes a fact with its evidence, so the next document resolves what is still open instead of everything.
Scope by workstream
Legal, financial and technical workstreams resolve different slices of the same model without sharing each other's context.
Trace every conclusion
The memo resolves findings that carry their source documents, so the trail from claim to evidence survives.
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.
- Diligence checklist
- Risk taxonomy
- Document taxonomy
- Findings and evidence
- Workstream scope
- Open items
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 due diligence, 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 due diligence
const context = await ensemble.resolve({
agent: "reviewer",
task: "assess_document",
subject: { deal: project-atlas },
});
// 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