Define the process once.
Every run follows it.
A process in Xema is a published, versioned definition, not a script somebody edited. It sequences steps, calls capabilities, stops for a human where a decision matters, and leaves a versioned deliverable at each stage. Agents do the steps — but the process, the gates and the record belong to the platform. Which is why the second run behaves like the first.
From a request to finished output.
A request comes in, agents gather context and do the work with the tools each step is armed with, and the run stops where a person has to approve. What comes out is a versioned deliverable, tied to the run that produced it.
Four ways
work begins.
Set the goal.
Get it done.
1The process is a definition, not a script
It is authored once and compiled into a dependency graph: steps, the order they may run in, what fans out in parallel, what each retry and timeout is.
2Every version is kept, and going back is cheap
Publishing writes a new immutable revision and moves a pointer to it. The old revisions stay exactly as they were — nothing is edited in place — so returning to one is a matter of pointing at it again rather than restoring over the top of anything.
3The agent does the work in a step
Inside a step, the agent decides its own moves — reading and writing in your systems through capabilities it was armed with, without waiting to be prompted at each turn.
4You stay in control
At the decisions that carry risk, the run stops at a gate and waits for a person. Reject it and it goes back for another pass, with the reason attached.
Hand off a task, or
work side by side.
The same agents that run a process on their own can also work with your team in a live session. A lead agent brings in specialist teammates — each with its own expertise and access to the right tools — and they carry a task together while a person watches, steers, and jumps in whenever they want.
One process. People and agents together.
Supplier onboarding.
- WhoWhat happens
- Purchasing managerStarts the onboarding and hands the document review to an agent
- Document agentChecks the documents and asks a compliance agent to verify the requirements
- Compliance agentChecks the requirements and asks a person to decide an exception
- Compliance officerReviews the exception and approves the next step
- Purchasing managerReceives the finished result
The work moves between people and agents without changing who may do what, or what is recorded.
1A lead you can trust
One agent owns the task and sets the direction — so there's always a clear owner accountable for the result.
2The right expertise, on tap
Each agent brings its own know-how and its own access to your tools. The lead calls in the right specialist for each part of the work.
3A real team, not one voice
Specialists work under the lead and can bring in help of their own, so complex tasks get the depth they need instead of one generalist stretched thin.
4You're always in the room
Watch the work as it happens, steer it in plain language, and step in at any point. Nothing runs behind your back.
Let agents run a repeatable process on their own, or work with them live for hands-on, long-running tasks. Either way they draw on the same shared knowledge and hand back the same finished, reviewable output.
Six questions.
No tool sprawl.
An agent is never handed a wall of tools, one per integration. It gets a closed set of six — search, describe, invoke, plan, preflight, explain — and uses them to ask the platform what exists. Install a package with fifty new capabilities and the agent's tool surface does not change by one entry.
1Search never offers what it cannot call
Results are filtered by what this agent is armed with and what its owner may actually do, before they are ranked — and the check that answers the search is the same one the invocation re-runs, so the two cannot disagree. There is no listing mode that shows the rest.
2It is a graph, not a list
Capabilities are related to the kinds of thing they act on, consume and produce. Search walks that neighbourhood from an anchor rather than scanning a catalogue, and falls back to a bounded, paged scan when there is no anchor to be had.
3Plan: a route to a goal
Given what the agent already holds and a capability it wants to reach, the platform returns the shortest runnable sequence over the graph — and names what is still missing if there isn't one.
4Preflight and explain: before and after
Preflight answers whether this subject can run this capability right now, and lists exactly what is blocking it. Explain answers why a refusal happened and what would change it.
Things you don't
have to build yourself.
The whole process, not a step.
From the first request to the finished result, the agent carries the work through every stage — no handoffs dropped, nothing left half-done.
Many things at once.
Run the same process across many teams, documents or cases at the same time, each run with its own record.
Reviewable results.
Every step produces real, versioned deliverables — documents, reports, reviews, working code — that you can open, compare, and reuse.
The way your company works.
Agents follow your steps, your rules, and your standards — not a generic template bolted onto your business.
The right path each time.
Work takes the route the situation calls for and skips what doesn't apply, without stalling or breaking the run.
Days, not seconds.
Processes that take hours or days run reliably to completion, surviving interruptions and picking up right where they left off.
Repeatable results.
Because nothing is edited in place.
The same request runs the same process every time, because the process is a published revision rather than a script somebody edited. Each organisation's runs execute in their own isolated environment, and a run is refused rather than started in one the platform could not verify.
Technical details
Runs execute in your organisation's own Temporal namespace, created the first time you need one. A run is refused when the namespace's retention settings could not be verified.
See it run on real work.
Follow a complete piece of work end to end — from the first request, through the steps the agent runs, to the human approvals and the finished, reviewable result.
What you get
- end-to-end delivery
- human gates built in
- works with your tools
- versioned deliverables
- every version kept
- runs for as long as it takes