Built for teams working in audited or regulated codebases.
Policy that can only tighten, human approval before anything runs, and a hash-chained record of what happened — while the work stays on your own machine.
v0.3.1 · macOS, Windows, Linux · solo use needs no account. Governing a team?
Sessions share the repo, not the files. zilix records which paths each one touches, so a clash surfaces as an approval instead of a silent overwrite.
Bank of America
Founders Inc
BLK Innovate
Protelo
Mirdain Systems
clusy.io
Zilix sits between your coding agents and your machine. An administrator publishes rules; every machine pulls and verifies its own copy; every tool call is checked before it runs; and what happened is written to a record that cannot be quietly edited.
An administrator writes rules and zilix signs them into a versioned bundle. A rule has exactly two possible actions — deny, or require a human to approve. There is no “allow”, so org policy can only ever make a developer’s agents stricter.
Each machine fetches its own bundle every 60 seconds, checks the signature itself, and installs the rules as a ceiling above whatever the developer configured locally. Local settings can only tighten it further.
At the tool call, not after it. The strictest rule that matches wins: the action runs, waits for a person, or is refused. A block your company wrote is final on the machine it governs — a local grant cannot lift it.
Every governed action is written to a local log where each entry is hash-chained to the one before it. Insert, edit, delete or reorder an entry and verification reports exactly where the chain breaks. Managed teams also get an off-machine copy.
Zilix runs an MCP server that every session in a repository can reach — so agents working side by side can see each other, check before they overlap, and say something when their approach changes. It works the same whether those sessions are Claude Code, Codex, or a model on your own machine.
| Tool | What the agent uses it for |
|---|---|
list_workspace_sessions |
Called early — find out who else is live in this repository |
peer_status |
Called before work that could overlap someone else’s |
coord_pivot |
Broadcast when its approach changes in a way peers need to know |
message_session |
Send one peer an actionable directive — not status chatter |
Every edit an agent makes records a claim on that file path. When a different session tries to edit a path a peer just touched, that one call is escalated to you with the conflict named — and the other session is told. It is deliberately advisory and time-bounded, not a lock: sessions working on separate files never interact with it at all. The point isn’t to prevent every overlap. It’s that an overlap becomes a decision you make instead of an overwrite you find later.
Where a runtime can’t be gated, we say so rather than dressing it up — a report-only rail is never labelled as enforced. And “keys stay local” means exactly that and no more: your provider credentials never leave the daemon, but the model provider you pick still receives your prompts and context, and an enrolled organization still receives metadata and audit records. The full data paths are here.
Zilix is the same application either way. On your own it is a local tool with no account. Inside an organization it gains a signed ceiling it cannot talk its way out of — and in neither case does your code move to somebody else’s machine. Hosted workspaces are not what this is.
Running this across a team? Managed organizations are set up with us directly, self-hosted or hosted. Tell us about your setup — or read exactly what is and isn’t true today first.
zilix runs governed AI coding on your own machine. A desktop workbench hosts local agent sessions, a local daemon controls execution and policy, and every consequential action stays visible to a human. Solo use is local and account-free. Managed teams add a signed organization policy ceiling, device trust, and centralized audit and spend reporting — without moving execution into a hosted workspace.