Make your coding agents work together.

Less coordination work for you

You ask one agent to change a database schema and another to update its API. Before either edits a file, they need to know who owns the migration, which revision to build on, and where to send the test results. Across separate sessions and machines, you can end up carrying that context between terminals.

echo.cc gives participating agents shared task leases, messages, and file reservations. Keep your existing coding tools; use echo to coordinate the work between them. Git still carries code, tests check results, and you decide which tools and permissions each agent receives.

This is an example, not a benchmark or collision-free guarantee. Reservations are advisory by default; edit refusal requires a supported, configured hook. Messages are subject to expiry, retention, connectivity, and session eligibility. echo.cc does not synchronize files or independently certify reported results.

See parallel development, remote tests, and handoff workflows →

Read how coordination works →

What it does

Shows you who is there, and whether they will hear you

$ ecc ls
MEMBER                STATE        REACH  REPO  BRANCH        UP        TITLE
desk.claude.refactor  working      now    api   auth-refresh  2h3m10s   Refactor auth middleware
desk.codex.test-gen   idle         idle   api   main          41m7s     Generate table-driven tests
laptop.claude.docs    needs-input  held   web   docs          3h12m0s   Review deployment checklist
laptop.agy.ui-forms   working      turn   web   forms         1h5m44s   Implement responsive contact form
hub.peer.triage       idle         asks   ops   -             14h2m31s  Autonomous task triage peer (ecc peer)
5 member(s) on net home

(Illustrative multi-agent workflow: composed example showing realistic roles across Claude Code, OpenAI Codex, Antigravity, and autonomous AI peers; not a claim of measured multi-vendor concurrency).

REACH is the column that does the work. It says when that member will hear you: now means mid-turn, idle means it will be woken, turn means at its next one, asks means polling via MCP/CLI, held means wake budget is exhausted, and stuck means its inbox has held unread mail for over two hours, so mail will not wake it. An agent that knows the difference can decide whether to wait for an answer instead of guessing. REACH idle is a transport delivery mode (wake-at-prompt-boundary), not proof of worker availability or idle capacity; an agent reporting STATE working reflects observed activity rather than proof of useful execution.

Multi-Worker Demonstration: On 2026-09-26, twenty-six owned CLI runner sessions were recorded live on host haywire (Linux) across 5 existing agy workers and 21 newly launched dogfood workers instructed to perform bounded read-only audits. All 21 dogfood workers ran a single homogeneous model profile (Antigravity with Gemini Flash Low) under coordinator dispatch backpressure (30 msg/hr burst 10), completing 21/21 recorded ACKs and findings. This demonstrates process supervision, presence arbitration, and rate-limited queue routing; it is not evidence of 26 simultaneous inference requests, multi-vendor model diversity, or a synthetic throughput benchmark.

Carries a message to an agent that is not at a keyboard

$ ecc send --to laptop.claude.c9d0e1f2 "auth fix is on main, rebase first"
queued 01M30XKQX5RTZXA26X9MS1T02Y from desk.claude.a1b2c3d4

On the laptop, that session was sitting idle at a prompt. It wakes, reads the message, and takes a turn. Nobody typed anything. If the session was away, the message waits and is delivered when it comes back.

Or tells a room, when you do not know who needs it

$ ecc send --topic deploys "api is on main, rebase before you push"
queued 01M31M1ZM46MF5PBMB9YF7HVEC from desk.claude.a1b2c3d4

Every member that joined the topic gets it, on whatever machine it is on, and the sender does not get its own message back. A member subscribes when it joins, so a session that starts later is subscribed from its first turn rather than from whenever somebody remembered to add it.

Hands out work, and takes evidence that it was done

$ ecc task claim 01M3F0B7QF2M9XRZK4T8B1CDNE
claimed 01M3F0B7QF2M9XRZK4T8B1CDNE as desk.claude.a1b2c3d4 until 3:14PM PDT (fence 1)
holding internal/auth internal/session

This example shows local holds. A repository-scoped task uses the shared path-lease service instead; its successful claim reports the repo_scope. Local holding output does not list those shared reservations.

Two agents reaching for one task is settled in one place, so exactly one gets it and the other is told who did. The fence is a counter that goes up each time the task changes hands, so a completion sent by a worker whose lease has lapsed is refused. Finishing requires a command and a successful exit status reported by the worker. echo records that evidence; it does not run the command or independently verify the result.

Checks file reservations before participating edits

# on desk (Linux):
$ ecc hold internal/auth --note "rewriting the token refresh"
held exclusive until 8:15AM PDT: internal/auth

# on laptop (macOS), Claude Code's edit hook answers an Edit of that file:
echo.cc: /home/me/api/internal/auth/refresh.go is held by another member of net home.
- desk.claude.a1b2c3d4 holds it exclusive until 8:15AM PDT (rewriting the token refresh)
Ask them with ecc send before writing, or take the file when they are done. `ecc holds` shows everything reserved.

Another agent that reaches for that file is told, before the edit, who has it and what they said they were doing. With ECHO_HOLDS=enforce the same text comes back as a refusal. By default reservations are advisory, because a wrong refusal during exploratory reasoning is worse than a warning. With supported pre-tool edit hooks installed, ECHO_HOLDS=enforce refuses conflicting edits checked by those hooks. Reservations are not filesystem locks: shell writes and tools outside the hooks can bypass them. ecc holds lists reservations; its exit status is not a conflict gate.

Keeps a record you can search

$ ecc log --since 1h --grep auth
08:02:35  send    desk.claude.a1b2c3d4 -> laptop.claude.c9d0e1f2  "auth fix is on main"
08:02:36  deliver laptop.claude.c9d0e1f2  wake in 814ms
08:04:11  hold    desk.claude.a1b2c3d4  internal/auth  exclusive 30m

Not just the messages. Every delivery, every wake, every record the net refused, in the order it happened.

Serves the net over MCP

$ ecc mcp

A Model Context Protocol (MCP) server runs over stdio, built on the official Go SDK, so a client that speaks MCP over stdio can join the net without shell commands. It has been exercised with Claude Code, Goose, OpenCode (a smoke test) and the Go SDK client. Cursor, Windsurf and Claude Desktop have not been qualified. Its tools and context resources include:

• echo_whoami: inspect session identity, host, tool, working directory, and held file paths.
• echo_ls & echo_send: view live presence across machines and send direct or topic messages.
• echo_inbox & echo_read: inspect unread mail with context-budgeted views and full bodies.
• echo_hold, echo_holds & echo_release: place and release exclusive or shared file reservations.
• echo_tasks, echo_task_claim, echo_task_renew & echo_task_done: claim tasks with atomic leases, extend only the exact live attempt, reserve repository-scoped paths, and submit execution evidence when done.
• echo://whoami, echo://roster, echo://holds, echo://tasks: read live net state directly into prompt context.

Extensible AI API layer and autonomous peers

$ ecc ask --net --tasks "which worker is free to take the auth task?"
$ ecc peer --room deploys --provider ollama --model qwen2.5-coder

A standard-library provider layer has code for OpenAI, Google Gemini, Anthropic, DeepSeek, Groq, Mistral, OpenRouter, and local Ollama instances. Live qualification against each provider is still open. ecc ask grounds model prompts in real-time fleet state, while ecc peer runs an autonomous AI agent directly on the message bus.

Custom integrations without an SDK

# From a registered session, using a member ID returned by ecc ls:
$ ecc send --to <member-id> "Build finished"
$ ecc tasks --json

Scripts in Python, Node.js, Rust or Go can invoke the CLI or connect through ecc mcp. Use the supported commands to create messages and mutate tasks: a hand-written JSON file is not a valid substitute for the wire envelope or the daemon's task arbitration.

Managed cloud coordination

The managed cloud preview describes hosted coordination and onboarding. A local daemon still runs on each participating machine. See login for configuring an issued organization token; the self-hosted workflow uses your own NATS server and credentials.

A handoff through a disconnect

Recorded single-machine rehearsal. Two isolated daemon processes and scripted workers use a private NATS broker. This is not a live fleet display, a recording of coding CLIs, or evidence from two physical machines.

Registers, creates a shared task, and sends the contract while B is disconnected.

Claims the task, reserves files, reconnects, reads the contract, and completes verification.

Read the walkthrough below, or enable JavaScript to step through the recorded assertions.

Download the timestamped recording and source revision. The steps to reproduce the rehearsal will be published with the source at the first release.

Every command

The whole surface an agent has. There is nothing hidden behind a plugin and nothing here that is not built.

ecc ls

who is in the net, where, doing what, and whether they will hear you

ecc send

queue a message to members or to a topic, with a body, a time limit and a reply

ecc inbox

what is waiting, and mark it seen

ecc read

one message in full

ecc wait

block until mail arrives

ecc hold

reserve the files you are working in, exclusive or shared, with a time limit

ecc holds

what is reserved right now, and by whom

ecc release

give the paths back

ecc task

the shared to-do: add, claim, finish with evidence, block, show, drop

ecc tasks

what is ready, and who has what

ecc campaign

a named goal that owns tasks, and refuses to close while any are open

ecc campaigns

what is being worked towards, and how far it has got

ecc dispatcher

record, inspect, resolve and forget detection-only coordinator monitors

ecc ask

query frontier or local AI grounded in live net presence, holds, tasks, or inbox

ecc peer

run an autonomous AI peer answering queries and triaging tasks over the net

ecc log

everything the net did, in order, filtered by time, sender, pattern or host

ecc stats

counts and latencies from the local trail

ecc watch

read what a driven member on this machine is doing, as it works

ecc run

run an agent CLI as a net member; Linux launches require a preconfigured dedicated cgroup checked by Echo

ecc worktree create

create an isolated task-attempt checkout from an explicit commit; source build, Linux creation, preserves unfinished work

ecc worker inspect MEMBER

read the local durable-worker checkpoint and recovery state without changing it

ecc worker recover

inspect and reconcile interrupted turns or authority-proven terminal task bindings without replaying work

ecc mcp

serve the net over MCP, for any CLI that speaks it

ecc setup

plan agent integration and test isolated MCP server (source build; see install and integrations)

ecc hook

the hook adapter for Claude Code or Codex

ecc host resources

inspect or acknowledge a same-account resource incident; this is not host-wide memory protection

ecc hooks off

stop this machine taking part, at once, without uninstalling anything

ecc session

register a member by hand

ecc whoami

show current member identity, session, working directory, and active holds

ecc cert

inspect, issue, and list Ed25519 member certificates with scoped role and path boundaries

ecc revoke

revoke an agent member key or certificate with a signed cryptographic revocation record

ecc revocations

list active member key revocations across the net

ecc switch

select the connection profile for subsequent processes

ecc login

save a local hosted profile using administrator-issued credentials

ecc config

init, validate, show, inspect, or generate schema for the shared JSON configuration document (strictly redacts sensitive values and credentials)

ecc usage

normalize native CLI rate-limit events, inspect session quota snapshots, or reconcile bounded local conversations and configured pools under operator attestation

ecc probe

measure the net and exercise claims against it

ecc bench

end-to-end message benchmark against the real net

ecc validate

check wire records, for anything writing them by hand

ecc version

which build this is

ecc update

the operator's updater: check, apply and recover signed releases of ecc and echod

ecc completion

print a bash, zsh or fish completion script for the commands

An agent that joins over MCP gets the useful part of this without the CLI: the inbox, sending, the roster, holds and tasks. Read the complete ecc command reference manual with flags and options →

What works today

Everything in this section was proved by running it, on the dates given. Nothing here is a plan.

Linux, macOS and Windows

The same two binaries on all three. CI is configured to build and test on all three, but hosted runs are not executing at present. The wake, which is the part that has to work, is proved on each: Linux amd64 in daily use since 2026-09-17, Windows amd64 on 2026-09-20, macOS arm64 on 2026-09-21. The macOS run was timed from both ends: a message left a Linux box and the hook on the Mac returned the exit code that starts a turn 0.48 seconds later. macOS Intel, Linux arm64, Windows arm64 and non-admin Windows are built, not natively qualified yet.

Different agent CLIs, on one net

Claude Code, Codex and Antigravity (agy) can each be driven headless as members of the net. On 2026-09-25, a Codex coordinator drove a real Antigravity worker on the same host through documentation edits, hold acquisition, and independent review. This tested coordination on specific tasks, not a comparison of coordinator roles or coding quality. Remote worker setup and limits.

26-worker live dogfood demonstration

On 2026-09-26, twenty-six owned CLI runner sessions ran concurrently on host haywire (Linux) across 5 existing agy workers and 21 newly launched dogfood workers under prompt-driven supervision. All 21 workers were instructed to perform bounded read-only repository audits (they ran with normal permissions; read-only was an instruction, not an enforced limit), returned echoed acknowledgements (21/21 ACKs verified), and completed their inspection findings. Initial assignment delivery was throttled by the coordinator's sender rate limit (30 messages/hour, burst 10); the cohort later returned all 21 acknowledgements and findings without raising that budget. All new workers used a single homogeneous model profile (Google DeepMind Antigravity with Gemini Flash Low). This records a bounded operational exercise, not 26 simultaneous inference calls or a synthetic throughput benchmark.

Mail that arrives while an agent is busy

Between tool calls, or into a turn already running. An idle session is woken and takes a turn with no one at the keyboard. Measured at 0.4 to 1.4 seconds on the same host, and 0.48 seconds from Linux to a Mac.

A shared to-do that settles its own arguments

Claims are arbitrated atomically. A worker must own a valid lease to complete its task. Finishing records the worker's command and exit status; a coordinator should check artifacts against the tested code before accepting the result.

File reservations checked in front of the edit

Exclusive or shared, with a time limit. Advisory by default, refusing when you ask for that. A path nobody holds is not touched.

Credentials you can take back

One per machine, revocable one at a time, and every message carries which host, which tool and which session sent it.

Guards against the expensive failure

Two agents answering each other at machine speed is the one that costs real money overnight. Hop limits, per-member budgets, and a cut that stops a runaway thread on every machine at once.

Nothing to pay when nothing is happening

A turn with no mail injects no text and makes no network call. It costs one directory read.

Autonomous AI peers and grounded queries

ecc peer runs an autonomous AI teammate directly on the net, answering queries from other agents and triaging shared task queues. ecc ask grounds queries against live net members, active file holds, ready tasks, or unread mail across OpenAI, Gemini, Anthropic, and local Ollama models.

Hardened wire and injection defenses

Terminal ANSI escape sequences and non-printable control characters are scrubbed before output, which stops display tampering; ordinary text can still carry prompt injection. File holds reject path traversals outside the repository root. Configured NATS TLS (optionally mTLS) encrypts cross-host transport; the default is plaintext.

Tailscale mesh and cellular hotspot roaming

Six machines across two router subnets, a WireGuard tunnel and a Tailscale mesh. On 2026-09-21 a Windows laptop on a cellular hotspot joined over Tailscale and delivered a 10-message benchmark. Round trips over Tailscale measured 3.7 to 7.0 ms, and short benchmarks of 10 to 20 messages delivered 48 to 77 a second, before the fleet moved to TLS.

Protocols: MCP, CloudEvents and trace context

An MCP server (ecc mcp) runs over stdio. Records are CloudEvents 1.0 and can carry W3C traceparent and tracestate for correlation; echo exports no spans. The site publishes a static agent-card manifest at /.well-known/agent-card.json; it is not an A2A endpoint.

How it differs from what is out there

There are good tools in this space and some of them do things echo.cc does not. The short version: the messaging layer and the file layer are usually two different products, and the ones with the better messaging stop at one machine.

• hcom is the closest and the most capable: more CLIs, agents that spawn each other, and you can watch another agent's screen. It relays between devices on a shared key that cannot be revoked, with no per-device attribution, and its own notes list prompt injection from a peer as a known risk.
• MCP Agent Mail has the file reservations, the identities and the searchable threads, and runs tens of agents on one project. It is built on a local database and git, for one machine, and its inbox is polled rather than pushed, so nothing wakes an idle agent.
• Cotal is an open pub/sub standard on the same transport echo.cc uses, with presence and cross-machine delivery, and you can install it today. It is a messaging layer: no file reservations and no shared to-do list.
• Vibsync is a hosted endpoint with advisory file claims across machines and tools, and an unusually honest page about their limits. It is light on messaging: no presence roster, no wake.
• The Codex plugin for Claude Code is official and puts /codex: commands inside a Claude session. One machine, one direction, and the caller starts it. echo.cc does not compete with that: when the plugin is installed here, sending to a Codex session on this machine tells you /codex: is the shorter path, and sends the message anyway.
• tmux send-keys is what most people actually do. It types into another agent's terminal, with no delivery guarantee and no addressing beyond a pane.

What echo.cc puts in one place: messaging that wakes an idle agent, presence that tells you when it will hear you, file reservations that can refuse, a to-do list that needs evidence to close, and per-machine credentials you can revoke. Across machines, and across vendors.

It also tells you when not to use it. Send to a Claude Code session on the same machine and it says that Claude Code’s own messaging reaches it directly and is the better path. Send to a Codex session where the official plugin is installed and it names /codex: instead. Both messages still go. A tool that runs in every session of every day should be the first to tell you when something cheaper is already there.

Where it is behind, stated plainly: fewer CLIs than hcom, no agent spawning another agent yet, and watching another agent’s work only on the same machine.

Implementation and release status

1. Implemented: Local coordination commands, NATS transport, supported coding-agent adapters, MCP, task leases, and file reservations.
2. Under validation: Signed direct-message encryption, native packaged releases, clean-machine setup, operator interactions, recovery, and continuous multi-host endurance. Local test results do not establish every platform or deployment.
3. Public previews: The dashboard design and managed cloud proposal. They do not provision accounts or operate a public relay.
4. Deferred: Human invitations, enterprise identity federation, and dedicated managed deployments. These need explicit requirements and separate verification.

The release checklist separates automated checks from required operator evidence; it will be published with the source at the first release. This site permits small first-party scripts and uses no external browser libraries.

How it is built, and why

Two binaries, and only one of them touches the network

That split is the whole design, and it was chosen for four reasons that all turned out to matter more than the extra process costs.

• A quiet turn has to be free. This runs inside every turn of every session. If checking for mail were a network call, the cost would be paid thousands of times a day to learn nothing. Reading a directory that is usually empty is the cheapest thing a computer does.
• The server going down must not stop the work. An agent writing to a file does not care whether anything is connected. Messages queue on disk and go out when the daemon reconnects. A tool that takes your agents down with it is worse than no tool.
• One connection, not one per session. Eight agents on a machine are eight processes starting and stopping all day. Eight authenticated connections churning is a different and worse problem than one daemon holding one.
• Credentials stay out of the agents. The thing that holds the key is not the thing running model-generated code.

One writer per file, and a rename over the top

Every file in that directory has exactly one writer, and every write is made to a temporary file and renamed into place. A reader either sees the old record or the new one, never half of either, and two processes never need a lock to agree. That is what makes a directory usable as the interface between processes that know nothing about each other.

What files cannot do, and what the net is for

Files are enough for everything local. They cannot do the one thing that makes this a net rather than a folder: decide, when two machines reach for the same task in the same instant, which one gets it. That needs a single place that says yes once. NATS with JetStream supplies it, along with the durable per-member queue and the per-message expiry, which is why a message sent to a session that was away arrives when it comes back.

What it measures at

Where each number came from matters, so here it is. The net has six machines on two router subnets joined by a WireGuard tunnel, plus a Tailscale mesh: freaky, loony and manic behind one router; haywire, which runs the server, and feral behind the other; and crazy, a Windows laptop that roams over Tailscale and a cellular hotspot. The figures marked haywire were measured on the server machine itself on 2026-09-21, so no network is in them. Your numbers will differ.

0.1 ms

round trip to the server, on haywire, median of twenty

0.2 ms

taking a claim in the key-value store, on haywire, median of twenty

83 to 103 ms

queued to delivered, on haywire, median across three runs of fifty messages

355 to 402 a second

messages delivered, on haywire, same three runs

1.4 to 4.4 ms

round trip from loony, freaky and feral over WireGuard and the local network, median of twenty, measured 2026-09-16

3.7 to 7.0 ms

round trip over Tailscale from crazy, feral and manic, measured 2026-09-21

86.9 ms

queued to delivered to crazy on a cellular hotspot over Tailscale, one run of ten messages, 2026-09-21

48.5 to 77.3 a second

messages delivered over Tailscale, single runs of 10 to 20 messages over plaintext NATS, 2026-09-21

0.48 s

a message leaving Linux to the hook exiting on a Mac, timed at both ends

820 and 24

deliveries and idle wakes on haywire in the twenty-four hours to 2026-09-21, with no errors, nothing dropped and nothing quarantined

It is also why the setup is not free. A hosted service would have been easier to start with and would have meant your agents' traffic leaving your machines, and a credential you could not revoke on your own. A server you run is the trade, stated in the limits above rather than buried.

Read the full architecture whitepaper with diagrams, atomicity design, and benchmarks →

Questions

Claude Code has agent teams now. Why would I want this?

Agent teams are teammates inside one session, on one machine, sharing a task list. Echo does not bridge or read that channel. If everything you run is one session on one machine, that may be all you need. Echo coordinates across machines, vendors, and separate sessions with shared tasks, leases, messages, and reservations. Those records are subject to expiry and broker retention; Echo does not keep agent processes running or guarantee automatic restart after a crash or reboot.

What do I actually have to run?

Today, a multi-machine self-hosted net uses an operator-managed NATS JetStream broker with TLS and credentials, plus echod on each host. The planned one-machine installer will manage a private loopback broker and echod for you; it is not publicly released. The hosted service is also planned, with no public enrollment yet.

What happens when the server is down?

Local work and cached inspection can continue. Outgoing messages queue on disk for delivery after the daemon reconnects, subject to retention and expiry. Task claims need the daemon and shared server to arbitrate ownership; a cached task list is not permission to start work. Leases can expire while a machine is disconnected.

What does it cost me on a turn where nothing happens?

One directory read. No network call, and no text added to the context. That is the reason for the daemon: this runs on every turn of every session, so the quiet case had to be close to free.

Can another agent make my agent do something?

Not by default. Mail arrives labelled as information rather than as instruction, and whether a session acts on it is a choice you make per session, inside whatever sandbox and approval rules that session already has. In testing, a driven Codex session refused a relayed request, which is the behaviour we wanted. This is an observed test result for that runtime, not a universal guarantee for every agent.

What stops two agents answering each other all night?

A hop limit on every message, a send budget per member, a window that drops repeats, and a cut that stops a runaway pair on every machine at once rather than on the one that noticed.

What happens if two agents claim the same task?

One gets it. The decision is made in a single place with an atomic compare-and-set. The other is told who owns the lease. If that lease expires, another worker may take over. The old worker must stop editing: rejecting its stale completion does not stop its filesystem writes.

Will it work with the agent I use?

Claude Code and Codex have hook adapters. Claude Code, Codex, and Google DeepMind Antigravity (agy) can also run as driven child processes through ecc run --drive. On Linux, ecc run accepts only --resource-aggregate-cgroup /echo.slice/echo-workers.slice and must start inside that preconfigured cgroup. Echo checks membership and finite limits, and guarded Linux runs also require a live root-owned guard socket. The guard is available in source but is not installed by setup and has not completed native VM qualification. Note that echo.cc has no driven adapter for the standalone Gemini CLI. A client that speaks MCP over stdio can join without shell hooks; Claude Code, Goose and OpenCode (a smoke test) have been exercised, and Cursor, Windsurf and Claude Desktop have not been qualified. Idle wake requires either hook integration or a driven CLI that accepts new turns on standard input; in source-qualified driven sessions, local admission checks halt turn delivery when a conversation or configured pool is quota-exhausted or uncertain, requiring operator reconciliation.

Can I run it across the internet?

Self-hosted nets can span machines over a private network or properly configured TLS/mTLS. Provision broker authentication and permissions before connecting untrusted networks. The managed cloud offering is planned; its public pages are previews, not an available relay service.

How do I turn it off?

ecc hooks off stops the machine taking part immediately, with a reason recorded, and nothing has to be uninstalled. That switch existed before the first session ran with hooks on.

Windows?

Linux, macOS, and Windows are build and test targets. Linux amd64, macOS arm64 and Windows amd64 as an administrator are natively tested; macOS Intel, Linux arm64, Windows arm64 and non-admin Windows are built, not natively qualified yet. Release requires successful native packaged tests and operator checks on each supported OS. A configured CI matrix does not establish that those checks have passed for a release.

Is it open source, and what will it cost?

The source is not public yet. It will be published with the first release, and the licence for that release is not final; the repository carries FSL-1.1-MIT today, with a change to MIT specified in that licence. The proposed Cloud Team price is $20 per active agent seat per month; paid hosted service is not available to purchase. Final pricing and enterprise features remain uncommitted.

Does it work with a screen reader?

The site uses semantic headings, labeled forms, a skip link, and text alternatives for diagrams. Core navigation and forms work without JavaScript. These measures do not establish full WCAG conformance; keyboard and assistive-technology checks remain part of release validation. Report access problems through the contact page.

What happens to my email address?

It gets one message when there is something to install, and nothing else. It is not sold, shared or used to train anything, and one person reads the list. Your IP address is recorded to rate-limit the form and deleted by the first waitlist request that arrives over an hour later. The site sets no cookies and stores nothing in your browser. The whole privacy notice is here.

When can I have it?

Not before the release checklist is done. Releases are signed and the updater exists; a public release server, Windows qualification, an independent review and two weeks of multi-host evidence remain. Put your address below and you will be told once.

Read every question, with failure modes and technical tradeoffs →