A software house and its runtime

Massively parallel AI. Transparency and reliability built in.

Go beyond agent orchestration. Z8 brings parallel execution, live visibility, and recovery into one runtime for critical operations. Run coordinated swarms of lightweight, isolated nanoservices, with human oversight and audit trails built in.

Z8 brings together the technology and the engineers who created it. We build production systems for your business, or license Z8 per project so your team can build its own. Both paths include full source code and a perpetual project license.

Talk to us Read the comparison
The Z8 dashboard's Swarm page: a topology of domain aggregates and reactors around one event-sourced application
The Z8 dashboard, live. The Swarm page of a production application built on Z8 — a real capture, with the application's names changed.
Millions of isolated processessupervised, preemptively scheduled, on every core
Event-sourced by defaultthe log is the truth; replay never calls a model twice
Dashboard includedswarm, agents, jobs, events, cost, compliance, tenants
Source-availablefull source, perpetual license, per project
Use cases

Three systems, three stages.

One in production, one about to launch, one drawn on Z8 for a regulated industry. Each case says what was hard, why a request-and-response stack in Python could not carry it, and what the runtime changed. Client names are left out on purpose.

In production

Adaptive coaching, run by thirty-one agents.

A member's own material becomes a living programme: one agent maps prerequisites, others write and independently review every task, others watch how the person is doing. Every decision is a replayable fact. The dashboard captures below are this system.

31 agents30 workers24 reactors15 read models
Read the case
Pre-launch

A store run by eighteen agents.

A creator directs a roster of specialised agents for design, pricing, growth and money. Every consequential change parks for a one-tap approval; every external side effect gets a receipt, even when the outcome is unknown.

18 roles32 state machines30 workers208 event types
Read the case
Blueprint

Clinical trials, with AI under a human gate.

A multi-party, regulated platform where AI drafts and cross-checks long documents and every change passes a person. It runs on a serverless stack today; this is the Z8 architecture for it, and why.

46 timers → 1 queue16 document types3 review passes1 audit chain
Read the case
The runtime

What it does.

Ten properties of a production agent system, present as defaults rather than as projects.

01

Concurrency

Each agent is a lightweight process: isolated, preemptively scheduled, a few kilobytes. Millions fit on one node, across every core.

02

Fault isolation

Processes are supervised. One that crashes is restarted in milliseconds, and the rest of the fleet does not notice.

03

Real time

Live server-rendered views stream tokens, follow runs and render read models in-process. Signals travel a CloudEvents bus with wildcard routing.

04

Durability

Durable agents are event-sourced: a pure decide / evolve pair over an append-only log, in Postgres, a file WAL or memory.

05

Replay

A past run is rebuilt from its recorded events. The model is never called again, so replay is exact and costs nothing.

06

Jobs and schedules

A queue with retries, backoff, uniqueness, snooze, priorities, cron and one-shot schedules. Every transition is a recorded fact.

07

Observability

A dashboard folded from the event log: swarm, agents, runs, jobs, reactors, events, cost, compliance, tenants.

08

Cost control

A live token meter on every model call in the VM, budgets and quotas per scope, and a diminishing-returns stop.

09

Audit

A SHA-256 hash chain with Merkle proofs and a write-once mirror. GDPR erasure removes the data and keeps the chain verifiable.

10

Multi-tenancy

The tenant is an axis of the runtime: provision, suspend and decommission a customer's agents with one call each.

Compare

Twenty-five factors.

Z8 beside four widely used agent frameworks. Where they are strong, the table says so.

Twenty-five factors: Z8 compared with LangChain, LangGraph, CrewAI and AutoGen.
Factor Z8Own runtime LangChainPython LangGraphPython CrewAIPython AutoGenPython
Runtime & scale
ConcurrencyHow many agents run at once, and on how many cores Millions of isolated lightweight processes, all cores, preemptive asyncio · GIL asyncio · GIL asyncio · GIL Async actors · GIL
Fault isolationWhat one crash costs Supervised: one crash stays one crash, restarted in milliseconds Exception takes the worker Exception takes the worker Exception takes the worker Exception takes the worker
Scale-outAdding machines Clustering built into the runtime External orchestration LangGraph Platform (paid) CrewAI AMP (hosted) Experimental gRPC runtime
Footprint per agent Kilobytes per process A thread or process per worker A thread or process per worker A thread or process per worker A thread or process per worker
Backpressure & limits Pools, quotas and budgets, per tenant or agent Per-model rate limiter Do it yourself Max RPM per agent Do it yourself
Real time to the UITokens, approvals, live state on screen Live views + signal bus, in-process, no websocket layer to write Token streaming; transport yours Streaming modes; transport yours Token streaming; transport yours Message streaming; transport yours
Durability & recovery
State model Event-sourced: pure decide / evolve, the log is the truth In-memory objects Checkpoints, opt-in Flow state persistence, opt-in save_state / load_state, manual
Crash mid-run Rebuilds from its log and continues Run lost Resumes from last checkpoint Replay from last task Run lost
Replay without re-calling the modelAudit, debugging, recovery Exact, free, every time: zero tokens Re-run it Time travel re-executes nodes Re-runs from a task Re-run it
Durable job queueRetries, backoff, uniqueness, dead-letter Built in, event-sourced, with the same dashboard Celery / Temporal Platform task queue (paid) Celery / Temporal Celery / Temporal
SagasMulti-step workflows with compensation Correlate, command, compensate Do it yourself Do it yourself Do it yourself Do it yourself
SchedulingCron and one-shot Durable schedules, survive restarts External scheduler Platform cron (paid) Enterprise triggers External scheduler
Agents & reasoning
Agent models Mutable, FSM, durable, graph, worker, reasoner: one declaration Chains + tool loop Graphs Crews + flows Conversations + teams
Reasoning strategies Eight: ReAct, CoT, CoD, ToT, AoT, GoT, TRM, Adaptive Tool loop; the rest yours You build the graph Loop + planning Group-chat patterns
Graph workflowsChannels, reducers, fan-out, interrupt The LangGraph model, event-sourced and replayable Via LangGraph Its core model Flows GraphFlow
Human in the loop Durable inbox, maker-checker approvals, live steering Middleware interrupt / resume human_input flag User proxy / handoff
Long-term memory Recall, sleep-time consolidation, working notes Integrations Store Built-in memory Memory protocol
Model routingAny provider, by alias Aliases + routing by intent init_chat_model Via LangChain LiteLLM Model clients
Multi-tenancyOne customer = one isolated runtime A first-class axis: provision, suspend, decommission with a GDPR sweep Thread an id by hand Thread an id by hand Thread an id by hand Thread an id by hand
Operations & governance
DashboardRuns, jobs, flows, inbox, cost, tenants Built in, self-hosted, live LangSmith (SaaS) LangSmith / Studio (SaaS) AMP (hosted) AutoGen Studio (dev tool)
Cost control Live meter, budgets, quotas, diminishing-returns auto-stop Traced in LangSmith Traced in LangSmith Usage metrics Usage per message
GuardrailsPII, prompt injection, moderation Built in, at the input and output gates PII middleware Do it yourself Task guardrails Do it yourself
Tamper-evident auditSHA-256 chain, proofs, erasure Hash chain, Merkle proofs, WORM mirror, GDPR erasure that keeps the chain valid None None None None
Permissions & policyAllow / deny / ask Policy engine with graduated trust, gating every tool and effect Do it yourself Interrupt before a tool Do it yourself Sandboxed code execution
One libraryAgents, CQRS, jobs, signals, compliance, UI One namespace, one mental model, one test suite Assemble six to ten Assemble six to ten Assemble six to ten Assemble six to ten

Open-source cores as documented in 2026. Hosted platforms (LangSmith, LangGraph Platform, CrewAI AMP) are marked as add-ons. Z8's durable job queue is at-least-once with idempotent consumers; we make no exactly-once claims.

Compliance

Compliance, with evidence.

Cryptographic audit proofs. Off-chain personal data. Human review. Explore how Z8’s capabilities map to leading compliance frameworks.

Built in Configuration / integration Not mapped
Eight Z8 capabilities mapped to six selected compliance frameworks. Marks describe implementation support, not certification.
Z8 capabilitySOC 2 Type ISOC 2 Type IIHIPAAGDPREU AI ActLGPD
Audit & verifiable evidence
Hash-linked tamper detection
Merkle inclusion proofs——
Offline evidence verification——
Independent external anchoring——
Privacy & human oversight
Off-chain personal-data storage—
Salted payload commitments——
Legal-hold-aware pruning——
Human intervention & review———

8 highlights. 50 controls and 14 frameworks in the full guide.
Capability mapping; no certification claim. Sources and evidence for every control.

Compare all 50 controls
For developers, and their assistants

One structure. One vocabulary.

Most code is now written with a coding assistant in the loop. Z8 is shaped for that: one library, one naming rule, one home for every file, so an assistant like Claude Code generates code that is correct and lands where it belongs.

my_app/
├── app               boots the runtime
├── z8                the agent instance
├── es_app            the event-sourced application
├── modules           the manifest: every installed slice
└── payments/         one slice per domain
    ├── facade        what other slices may call
    ├── commands      intent
    ├── events        facts; wire types are forever
    ├── router        command → aggregate
    ├── transfer      a durable agent
    ├── projections/  read models
    ├── reactors/     handlers and sagas
    ├── workers/      durable jobs
    ├── agents/       this slice's AI agents
    └── actions/      units of work, also the LLM tools

tests/payments/       mirrors the slice, path for path

One naming rule

Z8 › Context › Layer › Module is the file path inside the library, and your application follows the same rule one level down: domain slice, then role, then module. A module's location is derivable from its name, and the reverse.

Fixed roles in every slice

Commands, events, a router, an aggregate, projections, reactors, workers, agents, actions. A slice only adds the roles it earns; nothing has to be invented, and an assistant that has seen one slice can write the next.

Generators that encode the shape

One generator per role, aggregate, projection, reactor, worker, agent and more, scaffolds compilable code into the layout, so the structure is enforced rather than remembered.

One model for everything durable

Jobs, runs, sessions, schedules and graphs are the same pure decide / evolve machine. Learned once, it is generated correctly everywhere, and tested without mocks.

Loud at compile time

Literal options, validated state transitions and graph specs. A typo fails the build with every problem reported at once, so the assistant corrects itself before you read the diff.

A manual written for machines

Z8 ships a one-page reference for LLM coders. Put it in the context window and the assistant writes idiomatic Z8 instead of inventing glue between libraries.

The dashboard

What you see in production.

Every page below is a real capture of Z8's own dashboard. It is folded from the event log, so what it shows is what happened.

In production

A production application built on Z8, captured live. The application's own names were rewritten before the capture; nothing else was touched.

The reference bank

The bank application that ships with Z8 as its reference: two tenants, synthetic traffic, deterministic offline AI. The pages a production capture cannot show without exposing its data.

Memory

What an agent remembers,
and where it is kept.

Each kind of memory is a type with its own operations and rules. Any store that meets a type’s needs can hold it, chosen in configuration; a pairing that cannot keep the type’s promises is refused at boot.

Supported With a condition Not supported
Ten memory types, what each is used for, and which of four storage options can hold it.
Memory type In memoryvolatile Local fileon disk Event storetransactional Tieredhot over durable
Built inships with Z8 today
SemanticWhat the agent has learned: preferences, corrections, constraints. Recalled by rank into later runs; a change supersedes the old fact instead of overwriting it.
EpisodicWhat happened: one searchable digest per finished run. The full transcript is read from the event log only when it is needed.
WorkingThe view for the current step: notes, recalled facts and the conversation, assembled under a token budget on every turn. Assembled from the other types for each model call. Nothing to store.
KnowledgeEntities, relations and decisions shared across agents, for questions that take several hops and for “why did we decide this?” — — —
Planneddesigned, not yet available
CommitmentA promise to act later: a follow-up, a reminder, a deadline. It survives restarts, and a revoked permission stops it before it fires. — fsync on commit write-through
ProcedureSkills captured from successful runs. A candidate never runs; an approval binds its exact content, so an edited skill needs a new one.
ProfileWhat is known about a user or a customer, kept apart from the agent’s own identity. A stated correction outranks an inference.
ObservationRaw readings from sensors and signals, in a bounded buffer that records what it drops. A reading becomes a fact only through admission.
InsightConclusions drawn across many memories by reflection, each citing its sources. Copies of one source never count as corroboration.
MetaMemory about memory: what is indexed, how far behind, consolidation and erasure progress. “No match” stays distinct from “not indexed yet”. Read from the other types’ indexes and catalogs. Nothing of its own to store.
In memoryTables inside the runtime. The default and the fastest; gone when the node restarts.
Local fileAn append-only log on disk that survives restarts. With fsync on every commit, it also survives a power loss.
Event storePostgres or a file write-ahead log, the same store that holds the event history and the job queue.
TieredA hot copy in memory over any durable store. Reads stay fast; the durable store stays the authority.

Memory is private to its agent by default. Sharing it within a tenant, with a group or across tenants takes an explicit grant that can be revoked.
Further stores follow when a project needs them: SQLite, Redis or Valkey as a hot tier, S3-compatible cold storage, pgvector or Qdrant as a vector index.

Working with us

Build with Z8.
Keep your version for good.

Full source. A perpetual license for your project.
Choose the program that fits your business.

Z8 for startups

Your free startup package.

Every startup joining Z8 receives our full software stack free, with a perpetual license for one named project. Build, adapt, and run your product commercially.

$0

Full source. One project.
Perpetual use.

Join the startup program

No revenue thresholds, royalties, or license fees triggered by growth.

Everything to get started

  • Z8 and its companion tools. Full source.

    The current versions, ready to inspect, build, and adapt within your project.

  • Guides & learning materials

    Documentation and worked examples to help your team understand the software and start building.

  • Video demonstration

    A walkthrough of the software in use and how its parts fit together.

  • One hour of consulting

    A session about your architecture, setup, integration, or next technical decision. Included once per joining startup.

Your version, for good. The free license covers the versions delivered when you join, without a subscription or trial expiry. Later releases are available through optional monthly Upgrade Support. Z8 upgrades are also included during a long-term development engagement.

No license-imposed limits on users, team size, tenants, agents, cores, or deployments within your project. You may sell your own product or service; reselling or redistributing the supplied software itself, or reusing it in another project, is prohibited.

Software rights and delivered versions are recorded in your signed project license.

Development services

Bring us the product
you want to build.

Any customer can contract Z8 for development and compliance implementation, with or without Upgrade Support. A focused integration, an existing system, or a complete product.

Real-time games

Give every match
its own running state.

Multiplayer backends, matchmaking, lobbies, and live game services. Isolated processes let us organize matches as independent sessions, with their own state and recovery boundaries.

Live messaging keeps players connected to the action; supervision gives us a structured way to handle failed workers.

Isolated sessions · Live messaging
Blockchain and compliance

Connect transactions.
Make controls verifiable.

Indexers, transaction tracking, wallet integrations, and live dashboards. Z8 handles independent feeds concurrently, with supervised workers, checkpoints, and retries for recovery.

We also implement compliance controls for blockchain and other applications: audit trails, access policies, data retention, and approval workflows. Z8’s event history helps your team trace decisions and prepare evidence.

Concurrent feeds · Traceable controls
AI & agentic systems

Build agents your team
can follow and control.

AI products, coordinated agents, tool integrations, and workflows with human decisions. Z8 lets agents work concurrently with separate state and supervision.

Z8 adds durable history, retries, approval steps, and a dashboard, giving your team a practical way to inspect decisions and manage failures as the system grows.

Supervised agents · Human control

We build with Z8 and its companion tools, on the runtime’s concurrency and recovery capabilities. Scope and fees are agreed separately.

Discuss your project
Startup services

Choose how we work together.

Optional upgrades, support, and development for startup projects, alongside your free software package.

Paid subscriptions and development work follow their separately agreed terms.

Company

Small by design.

Z8 is a software house founded and led by Henry Hazan. You work with the people who wrote the runtime.

Henry Hazan
Founder & Principal Engineer · sole partner

Henry is the author of the Z8 runtime. Fifteen-plus years building trading systems and fintech infrastructure, where a decision has to be right, provable and still standing after the machine it ran on is gone. A mentor in fault-tolerant concurrent systems, who has spent a career on the kind of runtime always-on messaging and telecom depend on.

Z8 grew out of that work: one library that makes the production properties of an agent system the default instead of a project.

Questions

Before you write to us.

Startup program

What does the perpetual startup license cover?

The versions recorded in your project license remain available for your project’s continued use. You can maintain and modify them as your business grows. The free package includes no entitlement to later releases, updates, or patches. Upgrade Support covers releases made available during an active subscription, without promising a particular feature or release date. Z8 versions delivered during a long-term development engagement also remain free perpetually for your project; full support and upgrades are included during development.

What can we do with the source?

Use and modify it within your named project, including making the internal copies needed for development, testing, deployment, and backup. Your team and contractors may work with it for that project under confidentiality obligations. You may not publish, redistribute, resell, or sublicense the supplied software, or offer it as a standalone library, framework, or competing development platform. Each additional project needs its own authorization.

Who owns our application?

You retain ownership of your application. Z8 retains ownership of its software. The supplied software is source-available under a project license; third-party components retain their own license terms.

What costs remain?

You cover your hosting, model-provider charges, and any other external services you choose. Startup Upgrade Support is optional at $49 USD/month. The separate monthly support package provides five hours at $99 USD/hour, totaling $495 USD/month. The free consulting entitlement remains one hour total per joining startup. Development services are quoted separately. Development engagements expected to last more than three months include free Z8 upgrades and full support during development. The startup package already includes a free perpetual project license; upgraded versions remain free perpetually for that project.

About Z8 & working together

What exactly is Z8?

Z8 is two things. It is a library for building AI systems: event-sourced agents, a durable job queue, CQRS read models and sagas, a CloudEvents signal bus, real-time interfaces, native multi-tenancy, a tamper-evident audit chain and a dashboard, in one runtime. And it is the software house that wrote it, which builds production systems for clients on it.

Who is Z8 for, and does anything run on it today?

Z8 is aimed at teams building AI systems that have to run unattended: many agents working in parallel on one problem, long-running work that must survive a deploy, decisions that need a human gate, and an audit trail someone will inspect. Today that is an adaptive coaching platform in production, a commerce platform run by an agent roster that is about to launch, and the reference bank application that ships with Z8; a regulated clinical-trials platform is drawn on it as a blueprint. The use cases section describes each one without client names.

Is Z8 open source?

No. Z8 is source-available and licensed per project. An authorized client receives the complete source code and a perpetual license to build, run, and modify one named project, including operating it commercially. You may charge for your own product or service, but may not resell, publish, redistribute, or sublicense the supplied software itself, or reuse it in another project. Startup projects receive the current versions free, with no revenue threshold.

Why a runtime of its own?

Because the properties an agent system needs belong in the runtime, not in services bolted around it. Every agent gets its own isolated, supervised, preemptively scheduled process, millions per node across every core, with restart semantics built in. Immutable data makes local reasoning possible for people and for coding assistants, and the runtime carries cache, messaging and background work itself, so there is less infrastructure around the application. Z8 talks to any LLM provider and any HTTP service, so the Python or Node services you already have can be called as tools.

Do we keep the code if we stop working with you?

Yes. You keep the complete source and the perpetual project licenses for versions already delivered. You can continue running and maintaining your project after Upgrade Support or development services end. Your team and contractors may maintain the code for that project under confidentiality obligations. Your application remains yours.

What does a migration from LangChain or LangGraph look like?

We start from what you have. Prompts, tools and graph topology map directly: the graph capability in Z8 implements the LangGraph model, channels, reducers, fan-out and interrupt/resume, on an event-sourced substrate. A typical rescue sprint runs four to six weeks from kick-off to production, with retries, the audit log, the dashboard and multi-tenancy included rather than rebuilt, and your team working alongside ours throughout.

How does pricing work?

Startups receive the current versions of Z8 and its companion tools free for one named project, with full source, guides, a video demonstration, and one consulting hour. Optional Upgrade Support costs $49 USD/month. A separate monthly support package provides five hours at $99 USD/hour, totaling $495 USD/month. Development engagements expected to last more than three months include free Z8 upgrades and full support during development. The startup package already includes a free perpetual project license; upgraded versions remain free perpetually for that project. Enterprise licenses are $24,000 for one project or $80,000 for five, with optional annual maintenance and assurance plans. Development services are available to any customer under a separately agreed scope and fee. Enterprise list prices are in US dollars, excluding taxes, and are indicative. Binding prices and terms are recorded in the agreements both sides sign.

Tell us what you are building.

We will identify your project, record the versions covered by its license, and arrange your software delivery and consulting session.

Join the startup program Discuss your project

henry@z8.run