Model rules as rules
Coding requirements and payer policies become objects with effective dates, so a note resolves the handful that apply to its specialty and payer.
← All use cases
Use case 13 of 28
AI Clinical Documentation
encounter → coding → summary → chart
Documentation is generated per encounter, but coding rules, payer requirements and note templates do not change per encounter. They are re-sent anyway, on every note, for every clinician, all day.
Where the spend goes
The same knowledge, paid for at every step.
This is the shape of the problem in AI clinical documentation: a pipeline where each step re-establishes context the previous step already had.
Recurring context by stepTypical pattern
encounter capturenote templates, specialty rules
codingfull code set and payer requirements
summarypatient history in full
chartingtemplates and requirements again
What we do here
How ensemble helps in AI clinical documentation.
Bound the history
Prior encounters become structured clinical facts with links back to the source note, so a summary resolves what is relevant rather than everything on file.
Keep scope strict
Patient data is tenant- and record-scoped in the model itself, so it cannot be resolved outside its boundary.
Run where the data must stay
The layer deploys inside your environment when the records cannot leave it.
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.
- Note templates
- Coding rules
- Payer requirements
- Patient facts
- Specialty rules
- Access scope
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 clinical documentation, 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 clinical documentation
const context = await ensemble.resolve({
agent: "scribe",
task: "generate_note",
subject: { encounter: e-9931 },
});
// 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