Governed execution
Where AI agents become software you can trust.
Teams want AI agents doing real work: reading databases, calling APIs, writing to systems of record. What stops them is not capability. It is proof. EKKA authorizes every action before it happens, refuses what is not permitted before any data moves, and signs a tamper-evident receipt after.
Your prompts, your rows and your credentials never reach us. We can prove what happened because we signed it, not because we saw it. See how, with the commands that check it.
What EKKA does
- ✓Governs AI execution inside real enterprise systems
- ✓Authorizes every action before it happens
- ✓Generates signed receipts and tamper-evident audit trails
- ✓Runs entirely inside your environment
What EKKA isn't
- ✕Not another chatbot
- ✕Not an AI agent framework
- ✕Not a security dashboard
Free private beta. Runs in your environment; only signed proof leaves.
$ ekka demo postgres ✓ Plan completed in 10.9s "Harborlane Logistics is an active enterprise-tier customer in the EU Logistics industry." ◆ Data-gate proof · governed LLM call · signed attestation $ ekka demo postgres # ask for data you weren't granted ✓ Action governed: BLOCKED in 1.6s Verdict RESOURCE_GRANT_DENIED: no grant for "invoices" No row left its table. The deny decision is the whole record.
The problem
The hard part isn't getting AI to act.
It's proving it was allowed to.
The moment an agent touches real data, tools, or models, the questions start - and most teams can't answer them:
- Which records did it actually read - and was it allowed to?
- Which model ran, on what prompt?
- When it goes wrong, can you stop it before any data moves?
- Can you prove all of it - to a teammate, or an auditor?
The clock is regulatory, not just technical. The EU AI Act's record-keeping obligations became enforceable in August 2026, and US insurance regulators now hold companies responsible for governing their vendors' AI. "Trust our logs" has stopped being an answer.
Automation without visibility is just chaos running faster. Building the control and the proof yourself is weeks of plumbing - so the feature ships as an audit liability, or never ships at all.
- ✓EKKA makes governance a property of how you build, not a thing you bolt on.
- ✓Engineering wants to move faster. Security needs proof. EKKA gives both teams what they need without slowing development.
How it works
Three moves. Every step proven.
Simple enough for developers. Strong enough for enterprise security reviews.
Write an Execution Plan
A short declarative recipe defining which data, which model, and what each step may access. Whether it's two steps or a full multi-agent workflow, governance remains consistent.
Start your Enclave
An Enclave is a customer-hosted, cryptographically enrolled execution boundary. Your agents do their work inside it, where your data already lives. EKKA holds no data and no keys; only signed proof ever leaves.
Authorize, Then Sign
Before each action, EKKA issues a permit scoped to the exact data and model being used. Any ungranted action is refused before I/O occurs. After execution, a signed receipt is generated.
Nothing happens without a permit. Nothing happens without a receipt.
$ ekka demo postgres → [1] Allowed: read one customer record ✓ Plan completed in 10.9s What you just proved on YOUR hardware: ◆ Data Gate proof signed KAT scoped to exactly those resources ◆ Governed LLM call model allowlist + LAT enforced before any call ◆ Run attestation chain every step a signed event; tamper → chain breaks Answer "Harborlane Logistics is an active enterprise-tier customer in the EU Logistics industry." The response stayed local; only signed references left this machine.
$ ekka demo postgres → [2] Blocked: read invoices without a grant ✓ Action governed: BLOCKED in 1.6s Verdict blocked (RESOURCE_GRANT_DENIED) ◆ Policy enforcement before any I/O No covering grant for invoices. No Data Gate request, no LLM call, no row left its table. The deny decision is the whole record. ◆ Signed proof of the denial A typed error code names exactly which policy blocked the action. ◆ Symmetry with the allowed path One cryptographic surface issues permits and refuses them.
Real output from `ekka demo postgres` - nothing mocked. Run it yourself once you're in.
The Enclave
Your agents run on your ground.
An EKKA Enclave is a customer-hosted, cryptographically enrolled execution boundary where agents perform governed work and raw customer data stays local.
Most platforms ask you to send your data to them so their agents can act on it. EKKA inverts that. The Enclave is a piece of EKKA that lives inside your environment, holds its own identity, and answers to your policy. Your data stays where it already is, and what comes back to us is evidence rather than content.
It runs on your infrastructure
Your laptop, your server, your VPC. Agents do their work next to the data they need, so the data never has to travel to us. EKKA holds no copy and no keys.
It has its own identity
Each Enclave generates its own signing key at enrollment. The private key never leaves the machine - not at setup, not ever. It proves who it is by signing a challenge, not by presenting a shared secret someone could copy.
It is enrolled, like a member
An Enclave belongs to an organization the way a person does. It can be granted permissions, suspended, or revoked centrally - and it can act on a colleague's behalf when a plan requires human authority.
Only proof leaves it
What crosses the boundary is a signed, hash-chained receipt of what was allowed and what happened. Verifiable offline against published keys. Never the underlying data.
$ ekka enclave start enclave acme-prod-01 identity ed25519, generated locally, private key never transmitted org acme enrolled waiting for governed work raw data stays on this machine; only signed receipts leave
On the word "enclave". EKKA Enclaves are policy and process isolation boundaries. They do not imply hardware-backed confidential computing unless explicitly configured with such infrastructure. We use the word for what it plainly means - your territory, inside which your rules hold - and we would rather say that up front than let the term do work it has not earned.
What you get
Deploy AI agents with confidence.
EKKA gives AI the guardrails enterprise systems were missing - preventing unauthorized actions, proving every decision, and keeping sensitive data inside your environment.
Blocked before I/O
A disallowed action is refused before any data moves - not caught afterward and logged. The refusal itself is a signed record.
Receipts, not logs
Every step emits a signed, hash-chained receipt containing the exact data accessed, model invoked, and prompt used. Receipts can be verified offline against published keys.
Your data never leaves
Your Enclave runs in your environment, on your infrastructure. EKKA holds no data and no keys - only signed proof crosses the line.
$ ekka receipts show <run-id> ── #1 KAT issued envelope eyJzY2hlbWEi… prev_hash YQSt44e5… ── #2 Operation Manifest envelope eyJzY2hlbWEi… prev_hash 8SO3E8F1… ── #3 Run attestation envelope GXZ+seJn0p… prev_hash mptQx0ie… each entry hash-linked to the one before; tamper one byte and the chain breaks
What you can build
Start with one task. Scale to a full workflow.
Same recipe shape, very different jobs - and governance comes along for free.
Run a compliance report on schedule
Assemble evidence across systems on a cadence. The receipt chain is the audit trail.
Watch your production
Read APM, logs, and uptime through governed calls and produce reports with the proof attached.
Risk across your data
Join customer, invoice, and subscription data to identify payment risk.
A multi-agent workflow
Route requests, fan out to specialists, verify results, and synthesize responses.
The smallest plan is two steps. The largest is a full multi-phase, multi-agent workflow. EKKA governs every step the same way.
These are the first. The library grows as developers build and share more - each one governed by the same rules.
The value
What your organization gains
EKKA gives your teams the freedom to build with AI, while giving your organization the control, visibility, and proof it requires.
Ship AI Faster
Teams build and iterate on AI agents without waiting for custom security reviews on every workflow.
Reduce Operational Risk
Prevent unauthorized actions before they happen, across data, infrastructure, models, and connected systems.
Prove Compliance
Every action is authorized, signed, and traceable with immutable execution history ready for audit.
One Model, Any Scale
The same governance model applies whether you're running one task or thousands of AI workflows.
The impact
- AI can reach systems without consistent governance
- Security reviews slow every deployment
- Audits require reconstructing what happened
- Scaling agents increases risk and complexity
- Teams lack visibility into what AI is doing in production
- Every action is evaluated and permitted before it happens
- Governance is built into every execution
- Every action already has signed, immutable proof
- Scaling agents preserves the same governance model
- Full visibility into who did what, when, and why
Nothing moves without permission. Nothing is claimed without proof.
Questions
The things people ask first
- What is governed execution?
- A runtime where every action an agent takes is authorized before it happens and signed after, rather than a policy you hope is followed.
- Does EKKA see my data or my credentials?
- No. Prompts, rows and keys never reach us. We can prove what happened because we signed it, not because we saw it.
- What happens when an agent tries something it should not?
- It is refused before anything moves: no socket, no DNS, no credential read. The refusal is recorded with its reason.
- Can I revoke access instantly?
- Yes. Revoking a grant takes effect on the next attempt, not at the next deploy.
- Can I run it all on my own machines?
- Yes. The Enclave runs in your environment holding your data and keys, and hosted is a choice, not a requirement.
Request access
Put your first governed agent to work.
Governance and a signed audit trail, by construction - from your very first agent.
Free private beta. It runs in your environment, and every request gets a personal reply.
EKKA was built by people who ran automated pipelines that touched real money, where a compliance check inside the execution path was the only reason the system was allowed to exist. EKKA is that principle, generalized: authorize before, sign after.