HAMMU.ai — Intelligence, Governed.

What it is

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

Hammu.ai executes complete business processes through bounded AI-agent roles operating inside template-defined loops, gates, steps, verification rules, and convergence paths. Agents don't chat their way to an answer. Every inter-agent handoff is governed, verified, and auditable.

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 & convergence

Complex decisions, governed end to end.

Real processes branch. Hammu governs the whole shape — routing, escalation, parallel review paths, dual-path verification, risk tiering, and convergence — 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.

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. Three audiences.

Every governed process produces three export tiers from the same verified execution — each shaped for who needs to read it.

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, convergence results, exceptions, and final confirmation.

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

Tier 03

Business Package

Final decision, executive summary, key risks, conditions, recommendations, management commentary, and visuals.

For: executives, managers, customers, stakeholders.

Tenant-configurable output formatting drives the Business Package per customer — branding, language, section ordering, regulatory disclaimers. 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

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