Business Operations
A Business Operation is a published, deterministic function with a typed contract, composed from Jiwari, Kebiki and Teban. Your workflows, applications and agents invoke it; Archiveris guarantees what happens inside.
Assess claim
v3.4 · productionclaim_id: ClaimId, actor: ActorClaimAssessmentIllustrative operation.
Why operations
Give an agent the tools and a prompt, and it will fetch the facts, interpret them, pick the rules, respect or ignore the answer, and decide what it may do next. Each step may be excellent. The operation as a whole is still probabilistic, because the agent owns the composition.
A workflow or an agent calls Jiwari, then Kebiki, then Teban, and stitches the results together itself. That is a legitimate and often sensible choice. The caller owns the sequence, the mapping between contracts, and whatever happens when one step returns something unexpected.
The caller invokes AssessClaim. The sequence, the mappings and the error semantics are inside a published, versioned artefact that was typed, tested and approved before it shipped. The caller chooses the operation; it cannot change what the operation does.
Both remain first class. Nothing forces a Jiwari, Kebiki or Teban call through an operation. Compose when you want a coarser contract and a guarantee; call the primitive directly when you want the control.
Anatomy
The most useful composition pattern runs a determination and then asks what that determination permits. Kebiki establishes what is now true. Teban establishes what that state allows, for this actor.
The same claim, the same determination, a different actor: an adjuster with a £25,000 limit may recommend or escalate. A senior manager with a £100,000 limit may approve. Nothing in the policy changed — the authority did.
Inside Assess claim
JiwariResolve the claim, the policy and the approvals
KebikiCoverage: covered. Settlement: 47,000
TebanPermitted for this actor, at this limitIllustrative operation. approve_claim is absent because the settlement exceeds this actor's authority.
Operate with AI
An automation, or a person, needs to know whether to release a payment. The answer depends on the current state of the claim, on determinations made under policy, and on the conditions that govern the action itself.
Each product contributes a different part of that answer, and each part can be inspected.
Jiwari
Supplies the claim, the actor and the approval state, from one governed model.
Kebiki
Evaluates the policy determinations: the approval route this claim takes, and whether it is compliant.
Teban
Answers whether payment may be released now, and names any outstanding condition.
Expense claim CLM-88412
An expense of $50 or more has no receipt, and no approved receipt exception is on file. Supply the exception approval and the answer changes.
The expense approvals are complete and the receipt exception is on file. Payment may be released.
A real evaluation of a sample expense policy, simplified for presentation. Teban states whether an action is permitted; your own systems carry it out. The technical detail, including the action name and the evidence paths, is on the Teban page.
The boundary
That one line decides what belongs inside an operation and what belongs in your orchestration tool. We are not building another workflow engine, and you would not want us to.
| Inside the operation | Outside, in your tools |
|---|---|
| Resolve context, determine outcomes, evaluate affordances | Deciding when the operation runs at all |
| Deterministic branching, validation, mapping between contracts | Waiting on people, timers, events and inboxes |
| Structured outcomes: eligible, needs evidence, escalation required | Collecting the evidence an operation asked for |
| A trace linking every underlying call | Long-running process state and retries across days |
When an operation needs more, it says so and returns. Your workflow collects what is missing and calls again.
Lifecycle
An operation is an Archiveris asset like any other: typed at build time, tested before it ships, versioned when it changes, and frozen once deployed.
Operations reference published versions of Jiwari, Kebiki and Teban assets. The compiler proves that what one produces satisfies what the next consumes, or requires you to map it explicitly.
A deployed operation pins its dependencies. When an underlying package changes, the operation does not silently change with it: a new candidate is produced, tested and approved.
Every underlying call contributes to the operation's trace: the context resolved, the determination made, the branch taken, the affordances returned, each back to its source clause.
Assurance
Three mechanisms, each belonging to the product that implements it.
In Jiwari, applications and agents operate against explicit entity types, fields and relationships. Every write is checked against the schema, attributed and reversible, and a change to the model is classed as additive, compatible or breaking before it lands. People, applications and agents reach the same data through the API and MCP, under the same permissions.
A decision or action package is an identifiable, approved version. Acceptance criteria drawn from the requirements, and generated tests, have to pass before a build is accepted, and a draft can be compared with production to see which outcomes would change. In Kebiki, AI assists while the package is built; the published package then executes deterministically, with no model call at decision time.
Kebiki decisions and Teban evaluations both return a reason and a stable code with every outcome, and a trace linking the result to the rules that fired and the passages they came from. A reviewer can inspect the basis of an outcome instead of reconstructing it.
Invocation
A published operation projects into the surfaces your teams already use, without changing its semantics. The same governed artefact answers an application, an agent and a workflow step.
assess_claim// REST POST /operations/assess-claim { "claim_id": "CLM-88412", "actor": "u_mgr_031" } // MCP, as a tool an agent discovers and calls assess_claim(claim_id, actor) // SDK archiveris.operations.assessClaim({ claimId, actor })
Tell us one decision or action that matters, and the systems it touches. We will show you the operation that governs it, and where it plugs into the tools you already orchestrate with.