The AI decides what it wants to do.
Xema decides what it may do.
Xema sits between your AI and the systems that run your business. It turns your APIs, tools, data and workflows into governed business capabilities — named operations with an owner, a permission, an approval path and a record.
People, agents, apps and workflows all reach your systems the same way, through the same decision. The question your organisation answers is “who may execute booking.change on this booking” — not which model called which endpoint.
Every AI project rebuilds the plumbing.
And invents its own idea of who may do what.
An assistant here, an agent there, an automation in a third tool. Each one wires up the same systems, holds its own credentials, and expresses permission as an instruction it was given. So the security review starts over every time, the work never accumulates, and nobody can answer “what is this allowed to do?” from one place.
Define a capability once.
Everything reaches it the same way.
A capability is the operation your business actually cares about — refund an invoice, change a booking, redline a contract — with its inputs, its risk, who may run it and who has to approve. It is the contract your organisation governs. The API, the workflow or the MCP server behind it is an implementation you can swap.
Name the operation, its schema, its risk, and what happens when it goes wrong. This is the thing your permissions and approvals attach to.
An internal API, an MCP server, a Xema workflow, an n8n automation, a partner's agent. Change the binding later; the capability the business governs does not move.
A person, an agent, an app, a schedule, an external platform. Same decision, same credentials boundary, same record — whichever one it is.
People, agents, apps and workflows sit above. Your APIs, MCP servers, SaaS tools and automations sit below. Nothing crosses from one to the other except through a named capability, and every crossing is decided, credentialed and recorded at the same point.
Reviews, document work, operations, and long-running sessions run side by side — on a schedule, on an incoming event, or on demand — each in your organisation's own execution namespace.
Many departments.
One foundation underneath.
A biome is the delivered software for a business domain — customer care, finance, legal, engineering — with its own capabilities, processes, knowledge and screens. Install a second one and you get a second domain, not a second platform: the same identity, permissions, connections, approvals and audit trail carry it.
Resolve every case the moment it arrives.
As a request comes in, an agent reads it against your knowledge base, answers the routine ones, and routes the urgent ones to a person — around the clock, without a queue.
Redline every contract against your playbook.
An agent extracts each clause, checks it against your playbook, and hands counsel a risk-sorted brief. The agent does the line-by-line; your team approves the deviations.
From idea to a shipped,
reviewed change.
An agent carries a feature through every stage — framing, plan, spec, implementation, review — pausing for a human decision where it matters, and leaving a versioned deliverable at each one.
Continuous checks, before standup.
Every morning an agent reconciles the books, scans for anomalies, escalates the criticals to the controller, and delivers the digest — every figure traceable to the work that produced it.
Ships reviewed code changes.
Agents review every proposed change against your standards, do the line-by-line work, and hand back a finished assessment — your engineers keep the final approval.
Turns your material into finished documents.
Agents draft, review and render documents against your own knowledge base and your own document templates — and every version is kept.
Resolves cases, not just replies.
Agents work each case against your knowledge and process to a real resolution, and bring in a person the moment it matters.
Turns raw context into ready proposals.
Agents assemble proposals, briefs, and answers from your deals and product knowledge — reviewed before anything leaves the building.
Reviews and redlines to a decision.
Agents check every clause against your playbook and deliver a risk-sorted brief; your counsel approves the deviations.
Runs recurring closes and checks.
Agents reconcile the books, scan for anomalies, escalate the criticals, and assemble the evidence packet — every figure linked to the step that produced it.
Runs the process, every time.
Recurring operational work executed the same way on every run, because the process is a published revision rather than a script somebody edited.
Delivers analyzed findings, not links.
Agents gather, read, and synthesize across your sources into a finished write-up you can act on.
One permission model, every department.
Whatever a team builds, it is the same capabilities, the same reach ceilings and the same approval path — so a second use case does not mean a second platform to govern.
You will change AI vendors.
You should not have to redesign your organisation.
The model you use today will not be the model you use in two years, and the platform you buy this quarter will not be the last one. What has to survive all of it is your own model of the business — its objects, its capabilities, and the rules about who may do what.
So Xema owns that layer and nothing else claims it. A model provider, an MCP server, an n8n workflow, another vendor's agent — each is an implementation sitting behind a capability you defined. Swap any of them and the permissions, approvals and audit trail are untouched.
That is also why the second use case is cheaper than the first: it reaches capabilities that already exist, under rules that already hold. The work compounds instead of scattering across disconnected tools.
Objects, capabilities, permissions and policies are defined in Xema. Everything else is a replaceable implementation, provider or participant behind them.
A prompt cannot reach past the capability boundary. Whatever an agent decides it wants to do, what it may do is decided somewhere it cannot edit — and the refusal is recorded with its reason.
Biomes are the delivered software: agents, capabilities, processes, knowledge and screens for a business domain. They all share one identity, permission, connection and audit foundation, so a second domain is not a second platform.
Start with everything external. Move as much in-house as you want. End up running your own models on your own hardware. Same architecture at every stage — there is no rewrite between them.
the models, the tools and the platforms change · what they connect to stays yours
You don't rent your AI strategy. You own the objects, the capabilities and the rules — and Xema is what lets the technology underneath change without them.
Control isn't a setting you bolt on.
It's how the platform works.
The controls sit on the path the work takes, not beside it. Every capability call — from a person, an agent, an app or a workflow — is named, bounded by the authority of the subject behind it, and either allowed, refused, or held for a human answer. The platform decides, not a process document and not a system prompt.
A platform.
And the team that gets it working.
Putting AI to work at the core of your business is part product, part program. Xema is yours to run — and we work alongside teams doing it, scoping the first processes, connecting your systems, and shaping the governance that fits.
Xema, the product
The foundation your AI work sits on — one capability model, one permission model, one connector edge, one audit trail.
- · Installs on your own hardware
- · Connectors for the tools you use
- · Every capability call decided
- · Grows by installing biomes
Our team, alongside yours
A hands-on team scopes your first processes, models your governance, and ships the first agents before handing them to your org.
- · Process & standards design
- · Governance & policy modelling
- · Co-built packages & connectors
- · Handover to your own team
What ships without you building it
A reference engineering solution, a library of connectors, and editions that go from managed cloud to a box with no network.
- · A full software-delivery solution
- · Connectors: SCM, trackers, chat, mail
- · Cloud, on-prem and air-gap editions
- · Local model inference on-box
Start with one process.
End with a layer everything uses.
We work with a small number of teams each quarter. We take one real process, turn the systems it touches into governed capabilities, and put it live under your own approvals — engineering, support, sales, legal, finance, operations, wherever the work is waiting.