The AWS of agentic infrastructure

Run an autonomous company.

ab0t is the cloud platform for fully automated companies.
Eight enterprise SaaS products that together form the core infrastructure your AI employees run on - identity, permissions, sandboxes, audit, events, LLMs, payments, and runtime.

Talk to us → See the eight layers
Products 8 · one platform
Deploy Cloud · on-prem
For Enterprise · founders
Status Design partners · 2026
Core layers

Eight products. One platform.

Each layer is a standalone enterprise SaaS product. Together they are the operating system of an autonomous company.

ab0t
1 Identity 2 Permission Aware Proxy 3 Sandboxes 4 AuditDB 5 Events & Hooks & Integrations 6 LLM Gateway 7 Payments 8 Agent Harness
The thesis

The next decade is built by AI employees, not AI tools.

Every company will be partly autonomous within five years. Most will be mostly autonomous within ten.

The shift isn't about a smarter chatbot or a better copilot. It's about agents that do the work — that hold roles, make decisions, spend money, touch systems, and answer for their actions. That kind of workforce needs infrastructure that doesn't exist yet.

ab0t is that infrastructure. Eight enterprise products that, together, form the cloud platform a fully automated company runs on.

// Heard recently

"We can ship an agent that does the job in a week. The reason we haven't deployed it is the eighteen months of identity, audit, permissions, and policy work that comes after."

// CIO · Fortune 500 financial services

// 03 Each layer in plain language

What every layer actually does.

01

Identity

Cryptographic identity for AI employees.

  • Per-agent verifiable identity
  • SSO & org-role binding
  • Agent-to-agent auth
  • Key rotation, revocation
02

Permission Aware Proxy

Policy enforcement on every action.

  • Pre-flight policy checks
  • Per-agent, per-tool rules
  • Allow / block / escalate
  • Real-time human-in-the-loop
03

Sandboxes

Where agents do their work.

  • Cloud desktops & browsers
  • Persistent or ephemeral
  • Frame-level recording
  • Boots in < 8s
04

AuditDB

Tamper-evident record of everything.

  • Cryptographically signed log
  • Compliance-grade query
  • SIEM & warehouse export
  • p99 < 18ms write
05

Events & Hooks & Integrations

Connect agents to the systems that matter.

  • Event bus & webhook fabric
  • Native SaaS connectors
  • Trigger & transform pipelines
  • Replay & backfill
06

LLM Gateway

Unified access to every model.

  • Anthropic, OpenAI, Google, OSS
  • Smart routing & fallback
  • Cost & rate-limit controls
  • Per-agent model policy
07

Payments

Spending power for AI agents.

  • Programmatic payment rails
  • Per-agent budgets & limits
  • Vendor & invoice automation
  • Spend-policy enforcement
08

Agent Harness

The runtime your agents run inside.

  • Loops, state, ancestral memory
  • Failure handling & replay
  • DAG planning & subagents
  • Heartbeat & observability
03 Sandboxes · in motion

Watch an agent do its job.

Cloud desktops and cloud browsers, built for autonomous use rather than test scripting.

Persistent or ephemeral. Observable down to the frame. Reset on demand. Every cursor movement, click, and keystroke recorded and policy-attributed to the agent that issued it.

  • [+] Linux, Windows, and macOS substrates
  • [+] Per-agent ephemeral or persistent sessions
  • [+] Frame-level recording for replay & review
  • [+] Boots in < 8s, snapshots in milliseconds
  • [+] Network egress controls per workspace
fig.01 · sandboxes
Sandbox walkthrough drop media/sandboxes-demo.mp4 — ideally a 20–30s screen recording of an agent operating across 2–3 windows
02 Permission Aware Proxy · in motion

See policy enforce itself.

Every tool call runs through pre-flight checks. Allow, block, or escalate — on millisecond budgets.

The dashboard view shows live policy decisions across your agent fleet: which agent asked for what, what rule fired, what the outcome was, and which calls bounced to a human reviewer.

  • [+] Pre-flight policy evaluation < 5ms
  • [+] Per-agent, per-tool, per-resource rules
  • [+] Reviewer queue for ambiguous decisions
  • [+] Policy-as-code with full version history
  • [+] Replay any decision against a new policy
fig.02 · proxy
Policy dashboard drop media/proxy-demo.mp4 or .jpg — the admin view showing decisions firing in real time
08 Agent Harness · in motion

Look inside a long-running agent.

The runtime view: planning DAG, ancestral memory, heartbeat, and the live tool-call surface.

What separates a seven-minute agent demo from an eight-week production deployment is observability. The Harness gives you a continuous, replayable trace of every loop iteration — what the agent saw, what it decided, what it did, and why.

  • [+] Planning DAG with sub-agent orchestration
  • [+] Ancestral memory across runs and restarts
  • [+] Heartbeat loop — proactive, not reactive
  • [+] Failure handling & deterministic replay
  • [+] Frame-level observability dashboard
fig.03 · harness
Runtime view drop media/harness-demo.mp4 — planning DAG, memory state, and live tool calls visualised
// 04 Live demo · AuditDB

Watch the audit layer work in real time.

A simulated stream of agent activity flowing through ab0t's audit pipeline. Every action signed, hashed, and policy-attributed. Flagged actions surface in the same feed for review.

auditdb.ab0t.com / live
streaming
15:18:35.291 agent.fin-04 · jira.create_issue(ENG-4421, agent triage) · sha:6749ddb4 verified
15:18:37.869 agent.ops-12 · http.post(hooks.zapier.com/...) · sha:2f2ea123 verified
15:18:40.673 agent.legal-02 · fs.read(/data/reports/2026Q1.csv) · sha:9a6d2bbe verified
15:18:42.315 agent.dev-07 · sf.update(Account 0019X · 2 fields) · sha:7aa63772 verified
15:18:43.532 agent.it-09 · mail.send(legal@, Q4 contract review) · sha:68083eb2 verified
15:18:44.954 agent.legal-02 · github.merge(ab0t/core#284) · sha:1ccd69e7 FLAGGED
15:18:47.082 agent.cs-21 · kv.put(runs/0192af · status=ok) · sha:4358a415 verified
15:18:49.209 agent.legal-02 · desktop.exec(rg "TODO" /repo) · sha:e0be5078 verified
15:18:50.828 agent.legal-02 · llm.complete(claude-opus-4 · 1.2k tokens) · sha:36424aeb verified
15:18:52.974 agent.legal-02 · browser.click(button[data-action="approve"]) · sha:b103699a verified
15:18:55.409 agent.dev-07 · fs.read(/data/reports/2026Q1.csv) · sha:d31533c1 verified
15:18:57.437 agent.fin-04 · calendar.book(acme corp · Q&A) · sha:6d293f1e verified
15:18:58.943 agent.dev-07 · fs.read(/data/reports/2026Q1.csv) · sha:747baa10 verified
15:19:00.495 agent.ops-12 · http.fetch(api.salesforce.com/v59/sobjects) · sha:d912a2f2 verified
verified 1965 flagged 155 signed 2120 agents 7
p99 < 18ms · tamper-evident
The stack

Use one. Use all eight. Use it your way.

Each layer can be adopted independently. Together they compose into the full agentic operating stack.

Most teams start with two or three — usually AuditDB, the Permission Aware Proxy, and Sandboxes — and adopt the rest as their agentic deployment matures.

Sovereign deployments available. APIs first. Open standards where they exist; new ones where they don't.

fig.01 · the stack AI Employees 08 Agent Harness 07 Payments 06 LLM Gateway 05 Events & Hooks & Integrations 04 AuditDB 03 Sandboxes 02 Permission Aware Proxy 01 Identity ab0t platform
// 06 Built for

The teams shipping autonomy in production.

Frontier AI labs

Substrate for long-running models

For teams whose models need somewhere to operate over hours and days — with stable workspaces, reproducible state, and frame-level traces of what happened. Buy the ground; ship the model.

Enterprise CIOs & CISOs

Agents you can put under audit

For organisations deploying internal AI employees that touch finance, HR, customer data, or production infrastructure. Identity, audit, and policy out of the box. Compliance-grade from day one.

Autonomous-first founders

Skip the eighteen months

For founders building a fully automated company from the ground up. Don't reinvent identity, payments, audit, or runtime. Adopt the stack, focus on the work the agents are actually doing.

// 07 The architecture

In technical terms, ab0t is an AI mesh network.

Every agent, tool, model, sandbox, and skill is a node. Every node has a verifiable identity, advertises its capabilities to a shared registry, and communicates through the same policy-bounded fabric. The eight ab0t products are the substrate that mesh runs on.

fig.02 · mesh topology Registry discovery · trust agent .ops-12 agent .fin-04 agent .cs-21 agent .dev-07 tool db.query tool pay.execute skill summarise skill classify
agent tool skill registry
Entity type 01 N nodes

Agents

Long-running autonomous nodes. Each has an identity, a role, a budget, and a policy boundary.

routed via Identity + Proxy
Entity type 02 M tools

Tools

Capabilities other nodes can invoke. db.query, pay.execute, mail.send. Versioned, signed, attributed.

governed by Permission Aware Proxy
Entity type 03 K skills

Skills

Reusable behaviours: summarise, classify, extract, reconcile. Composable across agents and roles.

indexed in Registry
Entity type 04 1:1 keys

Identities

Cryptographic credentials. Every node, every action, every payment cryptographically attributable.

issued by Identity

The registry is the discovery and trust layer. Agents publish what they can do; tools publish what they expose; skills publish their interface contracts. When an agent needs a capability it doesn't have, the mesh resolves it the way DNS resolves a hostname — with caching, signing, and policy.

This is what enables the next generation of work: an agent doesn't have to know in advance which tools or skills exist. It discovers them at runtime, verifies their provenance against the registry, and uses them under the same identity and audit guarantees as everything else in the mesh.

Frequently asked

Questions buyers ask before they reach out.

We've answered the questions enterprise teams, AI labs, and founders ask most often. If yours isn't here, get in touch — we like the hard ones.

ab0t is the cloud platform fully automated companies run on. It is composed of eight enterprise SaaS products that together form the core infrastructure for AI employees: Identity, Permission Aware Proxy, Sandboxes, AuditDB, Events & Hooks & Integrations, LLM Gateway, Payments, and Agent Harness. ab0t describes itself as the AWS of agentic infrastructure.
ab0t provides the operational layer enterprises need before deploying autonomous AI agents at scale: cryptographic identity for AI employees, policy enforcement on every tool call, cloud desktops and browsers as agent sandboxes, tamper-evident audit logging, event-driven integrations, a unified LLM gateway, programmatic payment rails for agents, and a production-grade agent runtime.
ab0t is built for three audiences: frontier AI laboratories whose models need to operate over hours and days; enterprise CIOs and CISOs deploying internal AI employees that touch finance, HR, customer data, or production infrastructure; and autonomous-first founders building fully automated companies from the ground up.
The eight ab0t layers are: 1) Identity — cryptographic identity for AI employees; 2) Permission Aware Proxy — policy enforcement on every action; 3) Sandboxes — cloud desktops and browsers where agents do their work; 4) AuditDB — tamper-evident record of everything; 5) Events & Hooks & Integrations — event-driven integration fabric; 6) LLM Gateway — unified access to every model; 7) Payments — spending power for AI agents; 8) Agent Harness — the runtime agents run inside.
Frameworks like LangChain and AutoGPT help developers build individual agents. ab0t is infrastructure — the cloud platform on which a fleet of agents runs in production. ab0t handles identity, permissions, audit, sandboxes, payments, and runtime concerns that every serious agentic deployment needs but that no framework provides. Most teams use a framework to build the agent and ab0t to run it.
AWS Bedrock and Azure AI are model-access services — they help you call LLMs. ab0t is agent infrastructure — it gives those agents an identity, a sandbox to work in, a policy boundary, an audit trail, payment rails, and a runtime. ab0t can use Bedrock or Azure as upstream model providers via its LLM Gateway, but solves a different layer of the problem.
An AI employee is a long-running autonomous agent that holds a role inside a company — making decisions, taking actions, spending money, and being accountable for outcomes — rather than answering questions on demand like a chatbot or copilot. ab0t's thesis is that the next decade of enterprise software will be built by AI employees, not AI tools, and that this workforce needs infrastructure that doesn't yet exist.
A fully automated company is an organisation where most operational work is performed by AI employees rather than humans. ab0t's design assumption is that every company will be partly autonomous within five years, and most will be mostly autonomous within ten. The platform is built to be the operating system such a company runs on.
ab0t is headquartered in Auckland, New Zealand. The company was founded in 2025 and is currently working with a small number of design partners through 2026.
Yes. ab0t is available as a managed cloud service, on-premises, or as a sovereign deployment for regulated industries and government use cases. The platform is API-first, uses open standards where they exist, and proposes new ones where they don't.
An AI mesh network is a system in which every agent, tool, model, sandbox, and skill is a node with a verifiable identity. Nodes advertise their capabilities to a shared registry, communicate through a policy-bounded fabric, and can discover and use each other at runtime. ab0t is, in technical terms, an AI mesh network — the eight ab0t products are the substrate that mesh runs on.
The registry is the mesh's discovery and trust layer. Agents publish what they can do, tools publish what they expose, and skills publish their interface contracts. When an agent needs a capability it doesn't have, the registry resolves it the way DNS resolves a hostname — with caching, cryptographic signing, and policy enforcement. Four entity types are tracked: agents, tools, skills, and identities.
A multi-agent framework is a programming model for orchestrating agents inside a single application. An AI mesh network is infrastructure: it operates above any specific framework, gives every node a verifiable identity, routes messages through a shared policy fabric, and lets agents from different teams or vendors discover and trust each other. ab0t's mesh runs across whatever frameworks the agents themselves are written in.
At runtime. An agent doesn't have to know in advance which tools or skills exist. When it needs a capability, it queries the registry, gets back a list of nodes that can provide it, verifies their provenance and policy compatibility, and invokes the chosen one through the Permission Aware Proxy. Every step is logged in AuditDB and attributed to the agent's cryptographic identity.
Every node in the mesh is issued a cryptographic identity by the Identity layer. Every message, tool call, and payment carries that identity as a signed credential. Nodes can verify each other's identity, role, and policy attributes before agreeing to interact. This is the agent-network equivalent of mTLS plus role-based access control, designed for autonomous workloads rather than human users.
Yes. ab0t's mesh is designed for both intra-organisational deployments (a single company's AI workforce) and inter-organisational federation (agents from one company calling tools or skills published by another). Federation uses the same identity, registry, and policy primitives, with cross-org trust boundaries enforced by the Permission Aware Proxy. Sovereign deployments stay sovereign; federated deployments interoperate by signed contract.
ab0t is currently working with design partners. Organisations shipping autonomous agents at scale, or building companies that will be largely run by them, can request access by emailing [email protected].
Get in touch

Building an autonomous company? Let's talk.

We're working with a small number of design partners through 2026. If you're shipping autonomous agents at scale — or building a company that will be largely run by them — we should be talking.

Request access → Read the docs