# Nucleic — Where agents live
Nucleic is where coding agents live — their work backed up as it happens, their sessions outliving any one machine, nothing they do unseen. Fused from your Macs, iPhone, and cloud runners. Always answering to you.

Built for macOS 27

# Nucleic is where
agents live.

One place for your coding agents, fused from your Macs, iPhone, and cloud runners — where their work is backed up as it happens, their sessions outlive any one machine, and nothing they do goes unseen. Always answering to you.

Download for Apple Silicon
Only Nucleic has the Core 3 — Carbon, Covalence, Control ↓
And it's on iPhone. Meet the companion app →
No account required · private by design · runs offline
Supported agents
Claude Code Codex Grok Build OpenCode Hermes Agent Cursor Agent OpenClaw
+ any ACP-compatible agent

## The agents grew up. Where they live didn't.

Today an agent's whole life is one process in one terminal on one machine. Close the laptop and it stops. Lose the disk and its work is gone. Run several at once and they collide — and you see almost none of what they did.

Nucleic is what's been missing underneath them: a place where agents persist beyond any one machine, are backed up as they work, run on whichever host suits them best, and are observed down to the kernel. You stay in command.

The home layer

## Everything a terminal never gave them.

Four things a process in a terminal never had — and the reason a fleet you can trust becomes possible at all.

01 · persisted

### A life beyond one machine

A session isn't a process squatting in a terminal — it's a durable thing Nucleic keeps. Close the lid mid-turn and the work carries on. Hand a live session to the Mac that stays home. And if a machine dies outright, the mesh already holds what it takes to bring the agent back.

02 · backed up

### Backed up as it happens

Every word of every session and every change to every file is mirrored across your devices the moment it's made — byte-faithful, encrypted the whole way, on disks you own. And Carbon is engineered to keep even uncommitted work recoverable to within seconds.

03 · orchestrated

### Orchestrated, intelligently

Work goes to the machine that suits it best, not the one it happened to start on. Jobs park durably when no host is free, sessions rebalance between turns when a stronger machine opens up, and cloud runners boot on demand — then scale back to zero.

04 · observed

### Observed, down to the kernel

On its own ground, Nucleic sees by construction: nash, its shell, witnesses every command and every byte through a pipe — and narOS is reaching further down, to kernel-level observation of every file an agent touches. Facts, not inference.

The Core 3

## Three layers. One machine.

Under the cockpit, Nucleic is built from three elements — a memory, a nervous system, and a brain — each owned end to end, each named for what it does.

carbon is what you have · covalence is how it travels · control is where it runs
01data layer ↓
C

### Carbon

The permanent record — every session kept faithfully and mirrored across your devices.

02network layer ↓
Cv

### Covalence

The bonds between your devices — one encrypted mesh, one source of truth on every screen.

03system layer ↓
Ct

### Control

The brain — sandboxes, machines, and sessions orchestrated across everything you own.

CCarbon · the data layer

## Everything your fleet does,
on the record.

Carbon is the layer that remembers. Every session's full story — the conversation, the changes, even work in progress — becomes a byte-faithful Carbon Copy, kept on your devices, mirrored between them, and ready to pick up anywhere. Local-first. Always yours.

### Replay, instantly

Reopen any session and it replays in an instant, exactly as it happened — no re-running the agent, no round-trip to anyone's cloud.

### Copied, continuously

Your live work — even changes you haven't committed yet — is quietly mirrored across your devices, encrypted the whole way. Losing a machine costs seconds, not days.

### Yours, on your disk

Code, transcripts, and everything else Carbon keeps stays on your machines, under your keys. Nothing has to be uploaded for Nucleic to run.

Carbon in depth What a Carbon Copy actually holds, how it's mirrored, and what happens when a machine goes down. →

every word kept · every change mirrored · a lost machine costs seconds, not work

CvCovalence · the network layer

## Your devices, bonded.

Covalence is the nervous system — the mesh that bonds your Macs, your iPhone, and your cloud runners into one machine. Every path end-to-end encrypted; every job free to run anywhere; every session free to move.

### The fastest private path

Side by side or continents apart, your devices find the fastest private route to each other on their own. When nothing else reaches, a zero-config relay carries ciphertext — and only ciphertext.

### Dispatch to the mesh

Point a job at Covalence and it lands on the best host available — no picking a machine, no babysitting. Nothing free? It parks durably and dispatches the moment a machine appears. And when a stronger host opens up between turns, the session quietly moves there.

### Covalence Cloud

A headless Nucleic host is just another peer on your mesh — it keeps working while your Mac sleeps. Runners boot themselves when the fleet needs one and scale back to zero when it doesn't. Credentials arrive sealed, encrypted from your device to the runner, so the edge never sees a key.

Covalence in depth How your devices find each other, how a job gets dispatched to the mesh, and what Covalence Cloud adds. →

end-to-end encrypted on every path · sealed credentials · one source of truth on every screen

CtControl · the system layer

## Virtualization, orchestrated across your whole mesh.

Control is the fleet's brain. Agents work sealed off from your Mac in fast, disposable sandboxes — and when a job needs more, Control summons more: a full Linux machine, an entire Mac, even eyes and hands on a real screen. Every session runs wherever on your mesh it runs best; close the laptop mid-turn and the work picks itself up elsewhere. And it all stands on ground Nucleic built itself — its own operating system, its own shell — where nothing happens unseen.

### The lightest machine that works

Every job gets the smallest world that fits it — a fast, disposable sandbox by default, a real Linux machine when it needs a kernel of its own, an entire Mac when it needs Xcode and the Simulator. Summoned on demand, thrown away when the job is done.

### Eyes and hands

Agents don't just run code — they can see a screen and work it. On a Mac or Linux desktop of their own, they launch the app they just built, click through it, and check that it actually looks right before they call it done.

### Sessions that move

A session isn't chained to the machine it started on. Hand your laptop's work to the Mac that stays home, let it drift to the strongest idle host — or close the lid mid-turn and watch it carry on somewhere else.

### Seen, not guessed

On ground Nucleic owns, every command an agent runs and every git operation it makes is witnessed the moment it happens — by nash, the shell itself. Merges and conflicts land as facts, not inferences. That certainty is what earns unattended work its clearance.

Built for agents, all the way down

### Their own OS. Their own shell.

Most tools hand agents a borrowed Linux and watch from the outside. Nucleic kept going down the stack and built the ground itself — the operating system agents wake up in, and the shell every one of their commands runs through.

The operating system
narOS

The nucleic agent runtime OS — one purpose-built Linux that is the same machine everywhere agents work: every sandbox, every cloud runner, every Linux VM on your mesh.

- Ready at turn zero. Toolchains, runtimes, and a modern CLI kit come preinstalled, with package caches already warm — no setup turn, nothing to install first.
- The same ground everywhere. Built reproducibly from pinned sources, so an agent wakes up on identical footing in your Mac's sandbox and on a cloud runner an ocean away.
- Agent-first by construction. Its own init, a first-class agent user with room to work, and nash behind every shell an agent can reach.
- Reaching below. The narOS kernel is being built to watch — and gate — file I/O beneath every process, so nothing an agent touches can slip past the record.

narOS in depth →
The shell
nash

The Nucleic agent shell. Nucleic doesn't watch a shell from the outside — it is the shell, so everything an agent does at the command line is on the record by construction.

- Every command, witnessed. Each one lands with its full arguments, working directory, exit code, and timing — the instant it runs.
- Nowhere to hide. Pipes and redirects are tapped too, so even a curl | sh is seen for exactly what it carries.
- Never in the way. Byte-identical to bash, secrets masked before they ever leave the sandbox — and observing never slows a command down.

nash in depth →
Control in depth Repos Nucleic manages end to end, the machines it summons for a job, and the automation that certainty unlocks. →

one brain · every machine you own · its own OS, its own shell · work that never gets stranded

Why it matters

## One stack, owned end to end.

Most tools rent their foundations. Nucleic owns all three layers in a single native codebase — the memory, the mesh, and the machines — and, all the way down, the operating system, the shell, and the version control its agents work in. Each one strengthens the others: the mesh moves Carbon Copies, the VMs report to the cockpit, and the whole path from keystroke to merged branch runs on ground Nucleic commands.

3 layers · 1 codebase own OS · own shell · own VCS 100% Swift & SwiftUI end-to-end encrypted local-first · no cloud required
The cockpit

## Parallel by design. Safe by default.

Isolation, attention, and trust — the three hard parts of running a fleet. Solved by design.

01

### Real approvals

Agents ask. You decide. Every gated command and edit pauses for a risk-classified prompt — allow, deny, or modify-and-allow. First to answer, Mac or iPhone, wins.

02

### Work that ships itself

Every session gets its own worktree and branch, and finished work merges automatically — queued, conflict-aware, never mid-task. In nvrsion mode, agents even share one live trunk, edits serialized per file, so merge conflicts are structurally impossible.

03

### Idea inbox

⌘T captures a thought without breaking stride. Ideas queue in an inbox you can dispatch as a full agent run — one click, when the fleet has room.

04

### Orchestra

One frontier model conducts. A fleet of leaner workers plays in parallel — Fable 5 orchestrating, Sonnet 5 doing the heavy lifting. Frontier-grade thoroughness, at a fraction of the cost.

05

### Work from your iPhone

The cockpit, in your pocket. Watch sessions, answer approvals, and steer work from wherever you are — end-to-end encrypted.

Meet the iPhone app →
06

### Agent-agnostic

Claude Code, Codex, and Grok Build behind one approval flow. Plus any agent that speaks ACP, the open Agent Client Protocol.

Native to Apple platforms

## Made for the Mac. Every pixel of it.

No Electron. No web wrapper. Nucleic is 100% Swift and SwiftUI, with a native iPhone remote at its side. It looks, feels, and performs like it was born on your Mac — because it was.

### On-device intelligence

Apple Intelligence handles the local work — classifying turns, summarizing tool calls, triaging your idea inbox — privately, entirely on your Mac.

### Virtualization, the Apple way

Agents run in real, lightweight virtual machines born from macOS itself — nothing extra to install, nothing left running behind your back.

### Accessibility, built in

Four color-vision modes and five text sizes, applied across the entire app — a cockpit everyone can fly, not an afterthought in a settings pane.

macOS 27 (public beta) on Apple Silicon · native iPhone remote · signed & notarized

Open beta

## Give your agents a home.

Nucleic is in open beta. All it asks is macOS 27 on Apple Silicon.

Download for Apple Silicon
No account required
private by design · local-first · end-to-end encrypted