Pre-launch — building in public

Your agents run 24/7. Who's watching?

Zakuro is the execution-time control plane for autonomous agents. Real-time monitoring, audit trails, and enforcement so your agents can run in production without flying blind.

agent activity live
The problem

Every security tool you have was built for deterministic software

Autonomous agents are different. They plan, they improvise, they call tools with credentials you gave them and hit endpoints you didn't anticipate. Their behaviour is closer to the chaotic, creative, unpredictable nature of humans than to the software your monitoring stack was designed for.

There is no audit-grade, execution-time control layer for agents. Every material action needs evidence — who did what, when, and why — plus policy enforcement and incident reconstruction that satisfies compliance, passes audits, and contains failures fast. Without it, organisations face a binary choice: adopt AI and fly blind, or ban it entirely.

Build it yourself

Forward-leaning companies duct-tape custom agent infrastructure together, maintained by a small platform team that becomes a bottleneck. It works until someone asks "who audits this?" or that one engineer leaves.

Blocked entirely

Risk-averse organisations — often the ones that need AI most — can't adopt it at all. Every agentic product on the market asks them to send data somewhere new, and their existing DLP and vendor review processes say no.

Pressured into compromise

CISOs forced to approve agentic tools that don't meet their bar because the business demands it. They accept risk they wouldn't accept for any other category of software and hope nothing breaks.

Agents should be treated as autonomous entities, not as programs. The infrastructure you give them should reflect that. Treat them like employees — with the same identity, workstations, security controls, and access governance you provide to people.

How it works

Control where the damage happens

Zakuro sits at the execution boundary — between the agent runtime and the real side effects. Not inside the model, not after the fact. At the moment the agent tries to call a tool, use a credential, or reach a destination.

Phase 01

Deploy

provision + identity

Create agent identities in your existing infrastructure — Okta, AWS IAM, GitHub — with least-privilege defaults. Provision workstations on your compute. Manage secrets with explicit scopes and time-bound access.

Phase 02

Monitor

real-time evidence

Stream every tool call, network event, and state change. Capture audit evidence — who, what, when, why — with replayable trails. Detect drift and anomalies: unexpected tools, new destinations, unusual patterns.

Phase 03

Enforce

execution-time policy

Allow/deny decisions, approval workflows, and policy gates — all enforced at the moment of action. Not in the prompt. Not after the log file. At the point where the agent meets the real world.

Phase 04

Intervene

contain + respond

Pause agents, quarantine workstations, revoke tokens, tighten permissions — in minutes, not hours. Alert routing and escalation into your existing SIEM/EDR workflow.

Where we sit

The agent security stack

LLM firewalls catch bad prompts. Evals catch known failures pre-production. Your SIEM catches infrastructure-level events. None of them governs what the agent actually does in your systems at runtime. That's the gap.

Model / prompt layer
Prompt injection, jailbreaks, data leakage in text — Lakera, Llama Guard
Dev-time assurance
Evals, red teaming, CI gates — catches known failures before production
Execution-time controls
Tool access, credentials, approvals, network, audit evidence — Zakuro
Enterprise stack
IAM/SSO, SIEM/EDR, network inspection, DLP — Okta, Splunk, CrowdStrike
Principles

Trust architecture, not promises

ZERO TRUST

Agents are untrusted

The platform never assumes the agent process is benign. An agent may modify itself depending on its access level. Security controls exist at the OS, network, and platform level — not inside the agent.

IDENTITY

Real identities, not service accounts

Agents get first-class identities in your existing infrastructure — Okta, AWS IAM, GitHub — provisioned automatically as part of agent creation. Not service accounts bolted on later.

BYOC

Bring your own compute

Your agents run on your infrastructure. We never see your code, secrets, or data. Zakuro provides the control plane; you provide the compute.

BYOA

Bring your own agent

Run any agent code. The platform's security and identity model works regardless of what's running inside the machine. We provide a default runtime, but it's not required.

Who it's for

From solo builders to regulated enterprises

Prosumer

Individual builders

You're running agents with real credentials — GitHub tokens, cloud access, banking APIs. One over-permissioned token away from a very bad afternoon.

Readable timeline of actions, not raw logs
Safe defaults and "ask me first" approvals
One-click pause and token revocation
Growth stage

Startups in regulated spaces

A single agent incident becomes customer escalations, churn, or a breach story. "We're a small team" is not an acceptable answer to enterprise buyers.

Exportable evidence bundles for due diligence
Per-agent scoping and credential rotation
Incident reconstruction for customer response
Enterprise

Regulated industries

Finance, healthcare, government. Failure modes are existential. Your board wants agents deployed. Your CISO needs proof they're governed.

Audit-grade evidence with full traceability
Execution-time governance across tools and network
Integrates with IAM, SIEM/EDR, DLP
Team

We've lived this pain

Between us, we've built detection and response programmes where regulators actually look at the logs, and shipped data products from zero to exit in regulated industries. We know the buyer because we've been the buyer.

Founder / CEO

Product

Built and scaled data products across regulated industries — from zero to acquisition. The kind of work where messy datasets need to become clear UX, and where the wrong data in the wrong hands is a compliance incident, not a bug.

Founder / CTO

Security

Built detection and response programs where the threat model is real and the regulator is paying attention. Currently enabling a company to adopt agentic AI securely — the exact problem Zakuro exists to solve.

What a blocked action looks like up close

The $4,200 refund attempt from the feed above. Zakuro catches it at execution time, captures the full evidence chain, routes the approval, and logs the resolution. Every action, every decision, every second accounted for.

zakuro trace — finance-bot-7 / refund_threshold
14:31:18 action agent: finance-bot-7 tool: stripe.create_refund amount: $4,200.00 customer: cus_Nq4…x8K
14:31:18 policy rule: refund_threshold ✕ BLOCKED — requires human approval above $500
14:31:18 evidence trace: 9f3a…c21d identity: okta:agent-fin-7 context: invoice #INV-20260331-0847
14:31:19 route ⧖ approval request → slack:#finance-ops → @m.chen
14:32:52 resolved ✓ approved by @m.chen — refund executed human wait: 93s stripe: re_3Nq…pY1

Build with guardrails, not guesswork

We're onboarding design partners now — teams that need execution-time controls before they can put agents in production. If that's you, let's talk.