HAMMU.ai — Intelligence, Governed.

What it is

A runtime for governed work — not a wrapper around a model.

Most AI products wrap a model and hand you whatever it returns. Hammu is the layer that doesn't take the answer on faith — it runs the whole process, checks every step against the rules, and only lets verified work move forward. The language model is a component inside the runtime, not the thing you're buying.

What Hammu is

A runtime that executes complete business processes
Bounded agent roles inside defined templates
Every handoff governed, verified, persisted
Outputs that are verified audit artifacts
Recoverable decision chains, end to end

What Hammu is not

A chatbot
A copilot
Generic RPA
A workflow automation tool
Conventional RAG

How it works

Nothing advances unproven.

A process runs as a template-defined sequence of steps and gates. Each gate enforces verification before the next step is allowed to proceed — and every result is captured as a persisted artifact. The run produces a recoverable decision chain by construction.

01 Template-defined execution

Every process runs inside a defined template of loops. Behavior is bounded by design — the template determines what can happen, in what order, and what must be true before the work advances.

The same model applies whether the process is a financial period close, a mortgage adjudication, or a platform incident response. Templates configure the runtime's operational identity for a domain.

02 Gated, verified progression

Steps are organized behind gates. A gate must pass before the process is permitted to continue — verification is a precondition for progress, not a report produced afterward.

When a gate cannot be satisfied, the run does not silently proceed. The exception is captured, attributed, and recoverable.

03 Artifacts, not conversation

Unlike prompt-chain or swarm-based systems, Hammu agents don't collaborate through loose, uncontrolled back-and-forth where meaning drifts and nobody can say later what was actually decided. Every handoff is concrete and accountable — so the work doesn't depend on an agent “remembering” what another one meant.

The result is a decision chain you can replay, audit, and stand behind.

Branching

Complex decisions, governed.

Real processes branch. Hammu governs the whole shape — routing, escalation, parallel review paths, risk tiering — with the same gate-by-gate proof as a straight line. However many ways it forks, nothing advances unproven.

GOVERNED PROCESS · ADAPTIVE CASE REVIEW · RUN run_case_review_07_20260603_0914 Live · routing · 0 / 11 gates · 100% compliant

Activity Stream Live

Governance

Governance is structural,
not advisory.

Hammu doesn't suggest controls and hope they're followed. It enforces them. Governance is part of the runtime — not a prompt, not a policy document, not an afterthought. These mechanisms are how that guarantee is delivered.

M01

Template-Defined Execution

Every process runs inside a defined template of steps, gates, and rules. Behavior is bounded by design.

M02

Verified Context Handoff

Information moving between agent roles is checked for integrity, so a mistake in one step can't silently corrupt the next. What each agent acts on is trusted because it was confirmed — not assumed.

M03

Artifact-Mediated Handoff

Work passes between roles as concrete, reviewable outputs rather than loose conversation — so every exchange is accountable and nothing depends on an agent ‘remembering’ what another meant.

M04

Governed Memory Fabric

What the system knows and carries forward is controlled and attributable — so shared knowledge stays reliable across a long process instead of drifting.

M05

Dual Verification & Convergence

For decisions that carry real consequence, a result isn't trusted because one agent produced it — it's confirmed before it's treated as final. Confidence comes from proof, not from authority.

Most AI ships with guardrails. Hammu runs on rails.

Traceability

Traceability, produced
as it runs.

Most systems assemble an audit trail after the fact, reconstructed from logs. With Hammu, traceability is produced as the process runs — so a complete, source-to-output record exists by default, not as a later integration project.

Output

One run. Proof and result.

Every governed run produces the same proof — a technical trace and an audit package. Then it produces the result the process exists for: sometimes a report, just as often an action written into another system.

Tier 01

Technical Trace

Full structured execution trace — timing, model attribution, evidence linkage, and execution metadata.

For: engineering, internal audit, debugging, technical diligence.

Tier 02

Audit Package

Gates, artifacts, verdicts, calculations, reviewer rationales, evidence references, exceptions, and final confirmation.

For: compliance, risk, internal control, regulated reviewers.

Tier 03

Business Output

The actual result of the work. Sometimes a report — final decision, executive summary, key risks, conditions, recommendations. Just as often an action: a purchase order created in your system, a tenant provisioned, infrastructure scaled, a decision pushed to a downstream system.

For: executives and stakeholders — or the downstream systems that act on it.

When the business output is a report, formatting is tenant-configurable per customer — branding, language, section ordering, regulatory disclaimers. When it's an action, Hammu writes directly to the target system. Domain-configurable output identity, without code changes.

Architecture

Two layers. One engine.

Hammu operates at two levels using the same governance engine. Delivered as a Kubernetes operator, it runs on OpenShift and Kubernetes — governing the platform itself and the business processes that run on top of it.

Layer 1 — Platform Operations

It governs the platform itself.

A platform operations template governs the operational surface — provisioning, tenant onboarding, health response, incident management, backup orchestration, scaling decisions — through the same loops, gates, and verification that tenant workloads use.

A clean Hammu deployment with only this template loaded is a governed infrastructure management platform. Full stop.

Layer 2 — Business Process Execution

It governs the business on top.

Tenant-specific templates serve domain workloads — mortgage adjudication, employee onboarding, financial close review, vendor qualification. Each tenant gets a template that configures the platform's operational identity for that domain.

Business processes run on the platform layer and can invoke platform operations when needed.

Same governance engine · same loops, gates & verification · platform and business, governed as one

What it's worth

The work still has to happen.
The labor doesn't.

Every organization runs processes that recur — closes, applications, compliance, onboarding, claims, etc. They stay manual because no AI could produce a governed, verifiable record. Now one can.

Governed output

Same work. A fraction of the cost.

Hammu runs recurring processes end to end, governed, with the audit trail produced as the work runs — not reconstructed after. The verifiable record that kept these processes manual is now a byproduct of doing them.

At any scale

Twelve a year or a thousand a day.

A single enterprise modernizing operations. A government department processing applications by the thousands. A franchisor running shared services across a network of members. An MSP delivering governed processes to its own customers. The math is the same: process volume times labor saving. The bigger the volume, the wider the gap between what you spend and what the license costs.

How it's priced

You're replacing a cost center, not buying seats.

Pricing scales with the volume you run, not the people who log in. The justification is in your own actuals — take what you spend in labor today, compare it to the license. The platform pays for itself the moment the multiple clears.

One example — financial close at network scale:

A network of 1,000 members, each running 12 monthly closes.

12,000 closes × 6 hours × $50/hr = $3.6M in labor — conservatively. And that's just the close.

A Hammu license for a network this size returns 5× to 18×.

Engagement

Own the engine.
Or consume the outcome.

The same governed runtime, two ways to reach it — run your own instance, or trigger a run on ours and receive the finished, audit-traceable result.

Own the platform

For organizations running processes at volume — enterprise, government, MSP, or network. License the platform and operate it on your own infrastructure. Governed processes at marginal cost, under your control.

The full stack

Not just the output — the whole engine. Both layers, yours to operate: the governed platform and every process that runs on it, for your own operation and the customers you serve.

Governs the cluster

A native Kubernetes operator that governs the cluster itself — health checks, tenant provisioning, and deploys run as the same bounded, audited loops. The cockpit work a human operator runs becomes governed too, not just the AI payloads on top.

Consume the outcome

For organizations that want the result, not a platform to run. Trigger a run; it executes on our infrastructure; you receive a finished, audit-traceable result. Your data lives in a physically partitioned instance — secured, with every access traced to the credential. Fixed cost per run.

Template

A defined process, ready to run. A short, fixed onboarding connects your sources. Fixed cost per run.

Custom

Your own process, built from scratch. We learn your business, architect the workflow, and deliver it fully functional, verified, and end-to-end. The engagement scales to the work; the per-run economics don't change.

Defensibility

There's no ‘close enough.’

Any business process executed by AI — financial close, onboarding, vendor qualification — has to be done correctly. There's no ‘close enough’ when the output drives real business decisions. The only way to ensure correctness in agentic AI is governance that's architecturally enforced, not suggested. That this also satisfies the audit and traceability demands of regulated industries is a consequence of doing it right, not the reason it exists.

Three interlocking patents filedCIPO

Audit-native by constructionA complete record, produced as it runs

Enterprise-native deploymentKubernetes operator · OpenShift & K8s

See a governed process
run end to end.

Request a demo and watch a complete business process execute through gates and verification — and the audit package it produces by construction.

Request a demo → Contact