z8A software house with its own runtime

Vibe coding got you to the demo. We get you to production.

We build production AI systems on Z8, our Elixir runtime for agents, durable jobs and event-sourced state, for teams whose prototype has outgrown LangChain, LangGraph, CrewAI or AutoGen.

Talk to us See the 25 factors

Built on Elixir and the Erlang VM: the runtime behind WhatsApp, Discord and the world's telecom switches.

Millions
of isolated agent processes per node
0
model calls to replay any past run
8
reasoning strategies, one declaration
1
library for agents, queue, CQRS and audit
Where prototypes stop

Sound familiar?

Ten walls our clients hit before they called. Every one of them is a property of the runtime, not of your code.

01

Scalability

One event loop or one interpreter lock, a worker per core. A fleet that tops out at a few hundred agents.

02

Flexibility

Abstractions shaped for the demo that fight every requirement that comes after it.

03

Real time

Streaming bolted on with websockets, Redis and a broker your team now operates.

04

Crash recovery

A process dies and the run dies with it, halfway through a decision.

05

Fault isolation

One bad tool call takes the whole worker, and every run on it, down.

06

Observability

Traces in someone else's SaaS. Nothing about queues, jobs, tenants or cost.

07

Cost control

Token spend discovered on the invoice, not while it is happening.

08

Audit

No tamper-evident record of what was decided, by which model, on which input.

09

Multi-tenancy

A tenant id threaded by hand through every call, until the day one leaks.

10

Glue

An agent framework, a task queue, a broker, a database layer, a scheduler and custom everything. Ten libraries, one team.

Compare

Twenty-five factors. One honest table.

Z8 against the four frameworks our clients most often arrive with. Where they are good, the table says so.

Twenty-five factors: Z8 on Elixir compared with LangChain, LangGraph, CrewAI and AutoGen.
Factor z8Z8Elixir 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 LiveView + 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
Control roomRuns, 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.

One library

Ten libraries. Or one.

The usual path to production is an assembly. Z8 is one library with one vocabulary, and that matters more now that an AI writes half your code.

The usual stack

LangGraphLangChainCelery RedisKafkaSQLAlchemy AlembicFastAPIWebSockets APSchedulerLangSmithOpenTelemetry + the audit log nobody wrote

Twelve docs sets, twelve release cycles, and the glue between them is the code your assistant has to invent.

The Z8 stack

agentsCQRSjobssignalsreal-timecompliancecontrol room

One namespace, one mental model, one test suite, one version number.

Nothing to guess

Every module is named Z8.<Context>.<Layer>.<Module>, and the name is the file path. An assistant that has seen one module knows where all of them live.

One model, everywhere

Jobs, runs, sessions, schedules and graphs are all the same pure decide / evolve machine. Learn it once, generate it correctly everywhere.

Loud at compile time

A typo'd transition or a malformed graph fails the build, with every problem reported at once. The assistant fixes it before you read it.

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.

The platform

Everything production needs. Already in the box.

One declaration

A durable, auditable AI agent in ten lines.

Event-sourced, with a status machine, a sealed audit trail and replay that never re-calls the model. Add graph:, worker: or memory: the same way.

defmodule Claims.Triage do
  use Z8.Agent,
    durable: true,
    reason: [model: "anthropic:claude-haiku-4-5",
             prompt: "You triage insurance claims."],
    fsm:    [initial: :fresh,
             transitions: %{fresh: [:settled]},
             on: %{Z8.ES.Core.Run.Events.Completed => :settled}],
    audit:  [types: ["claim."]],
    snapshot: [every: 100]
end
Agents & reasoning

Eight ways to think.

ReAct, Chain-of-Thought, Chain-of-Draft, Tree-, Algorithm- and Graph-of-Thoughts, TRM and Adaptive, which picks per request. Tools, skills, guardrails, long-term memory and human approval ride along.

use Z8.Agent, reason: true
Event sourcing & CQRS

The log is the truth.

Pure decide / evolve aggregates, projections, sagas with compensation, snapshots. Postgres alongside your own tables, a file WAL, or in-memory.

Durable jobs

A queue you never install.

Retries with backoff, uniqueness, snooze, priorities, cron and one-shot schedules, orphan rescue, dead-letter and pruning. Every transition a recorded fact.

Real time

Live by default.

Stream tokens, follow runs, approve from an inbox and render read models straight into LiveView. Signals are CloudEvents on a wildcard-routed bus.

Control room

See the whole fleet.

Self-hosted and live, folded from the event log, so what you see is what actually happened.

swarmagentsrunsinboxflowjobspoolsschedulerreactorseventstracecostmemorytenantscompliancefirehose
Governance & compliance

Provable, not promised.

Policy with graduated trust, budgets and quotas, PII and injection guardrails. A SHA-256 audit chain with Merkle proofs and a write-once mirror, and GDPR erasure that leaves the chain verifiable.

Multi-tenant from day one: provision · suspend · decommission
How we work

We build it. You keep it.

Fixed scope, senior engineers, and the project license included. The source is yours when we leave.

Most clients start here
Rescue sprint
Your prototype, in production on Z8.
from$28,000
4 to 6 weeks · fixed price
  • Prompts, tools and graph topology ported, not rewritten
  • Durability, retries, audit log and control room on day one
  • Your team pairs with ours throughout
  • Project license included
Start a rescue
Build
A production agent system from a blank page.
from$60,000
8 to 12 weeks · fixed scope
  • Discovery to deployment, on your infrastructure
  • Event-sourced core, real-time UI, control room
  • Compliance posture designed in, not bolted on
  • Project license included
Scope a build
Embed
Senior Z8 engineers inside your team.
from$12,000/ month
month to month · 30 days' notice
  • The people who wrote the runtime, on your code
  • Architecture, reviews and pairing, not tickets
  • Scale up or down each month
  • Project license included
Add an engineer
License Z8

Or build it yourself. Full source, forever.

One payment per project, sized by company. Evaluate for free, for as long as you need; the license is due when you go to production.

For startups
Startup
Companies under 25 people.
$4,800
one-time · per project · perpetual
  • Complete source code, unlimited seats
  • 12 months of updates and email support
  • Then $1,800 / year, optional
  • Credited in full if you upgrade
Get the Startup license
Growth
Up to 250 people.
$24,000
one-time · per project · perpetual
  • Everything in Startup
  • Priority support, next business day
  • Two architecture reviews with the Z8 team
  • Then $8,000 / year, optional
Get the Growth license
Enterprise
Larger or regulated organisations.
from$80,000
per project, or a company-wide agreement
  • Everything in Growth
  • Support SLA with a dedicated channel
  • Security review, custom terms, workshops
  • A seat at the roadmap
Talk to us
PerpetualThe license never expires and survives the end of any services agreement.
Full sourceYou receive, modify and keep the complete code. Your app stays yours; nothing is copyleft.
Ship it your waySell it, run it as a service, deploy it anywhere, for any number of users.
One projectEach license covers one named product. The only thing you cannot do is resell Z8 itself.

Prices in US dollars, excluding taxes. Company size by headcount at signature. Upgrade a tier at any time by paying the difference.

Why this model: the people who wrote the runtime, and the runtime itself, are the same offer.

Every engagement ships with the license, so there is no lock-in to the software house: when our work is done you hold the code and the right to run it forever.

Every license comes with the people who wrote it. Updates and support are the renewal, not a meter on your usage, so your costs do not rise with your success.

Startups pay a few thousand dollars and get the same runtime a regulated enterprise gets. Growth and enterprise tiers pay for depth of support, not for features held back.

Company

Small by design. Senior by default.

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. An Elixir and Erlang mentor who has spent a career on the fault-tolerant runtime behind always-on messaging and telecom.

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.

What exactly is Z8?

Z8 is two things. It is a software house that builds production AI systems for clients, and it is the Elixir library those systems run on: AI agents, durable jobs, event-sourced state, real-time interfaces and a tamper-evident audit log in one runtime. Most clients come to us when a prototype worked and production did not.

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, modify, sell or operate one named project with Z8 inside, for any number of users. The one thing you cannot do is resell Z8 itself. Evaluation is free and unlimited: read it, compile it, test it, and pay when the project goes to production.

Why Elixir?

Elixir runs on the Erlang VM, the runtime behind WhatsApp, Discord and decades of telecom switching. It gives every agent its own isolated, supervised, preemptively scheduled process, millions per node across every core, with restart semantics built in. That is the property an agent fleet needs, and the one a single event loop or an interpreter lock cannot provide. Your models and data stay where they are: Z8 talks to any LLM provider and any HTTP service, so the Python or Node services you already have can be called as tools while you migrate.

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

Yes. The license is perpetual and survives the end of any services agreement. You keep the full source, including your own modifications, and keep running and evolving the project for as long as you like. Your application code is entirely yours; nothing in the license is copyleft.

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 control room and multi-tenancy included rather than rebuilt, and your team working alongside ours throughout.

How does pricing work?

Two ways. License Z8 for your own team: a one-time, per-project fee sized by company, with the first year of updates and support included and optional renewals after that. Or have us build it: fixed-scope sprints and month-to-month embedded engineering, with the project license included. Upgrade tiers at any time by paying the difference. Prices are in US dollars, excluding taxes.

Tell us where the prototype stopped.

A thirty-minute call. Bring the prototype; we will tell you honestly what it takes to make it production, and what it costs.

Talk to us See pricing

henry@z8.run