Soul Engine
A home for a long-running personal agent. Its memory, skills and your corrections live in a folder you own; Claude Code and Codex are just engines you can swap.
Second generation · runs every day
Personal agents stall in three places. Your memory is locked inside one vendor. A plugin gets every permission the moment you install it. And whatever the agent teaches itself goes live with nobody checking.
Split the agent in two. Memory, skills and corrections live in a versioned folder the user owns; the engine is whatever coding agent you plug in. Capabilities are modules that must declare what they need. Anything the agent learns has to pass a gate before it counts.
A native macOS app rebuilt from scratch in 13 days: three engines, eight modules, 255 automated tests. My own working day already runs on it.
- 13
- days from first commit
- 235
- commits
- 255
- automated tests
- 3
- engines
- 8
- modules
Real product screens, rendered by the app itself. The data is a demo: Mia, her agent and her open-source project are fictional. In the recording at the top, the engines are scripted stand-ins; the app, the engine switch, the event log and the approval card are the real thing.
Own the layer above the engines
Engines get smarter every month, and I use them daily; I am not competing there. What no single engine gives you is continuity across them: the same memory, the same skills, the same corrections whichever one is running, switchable in the middle of a conversation. The engine supplies the intelligence. This layer makes the agent’s growth belong to the user.
Mechanism, not policy
On day three I threw away two rounds of hard-coded rules. The skeleton now guarantees exactly one thing: what the owner decided is what actually happens. Every safety policy on top of that is pluggable, because the right policy for me is not the right policy for the next user.
Conservative by default
Approvals default to “ask me”. Nightly consolidation defaults to “propose only”. Automations default to read-only. A user can loosen all three; nobody has to tighten them after something goes wrong.
Keep the beliefs, drop the code
Generation one was an Electron and Python desktop app, and it still sells. I kept its three beliefs — your memory is yours, pay once, bring your own model — and rewrote everything else natively rather than migrate a design that had stopped fitting.
Type, approve, review the night report.
- Guards
- Policy
- Approval card (original request)
One event stream for every engine. A local control socket, no network port. A credential relay in front of the keychain.
Claude Code · Codex · any ACP agent
The model and the tools run here.
Manifest → sandbox rules. No network unless declared. Never holds a secret.
- memory/
- skills/
- corrections/
- modules/
- automations/
- events/
Outside the engine, on the user’s side. Swapping the engine changes the box above; this one does not move.
Nightly proposal → guards → night report → you
Draft → evaluation → regression → you
One abstraction, three engines
Claude Code, Codex and any ACP agent each speak a different protocol. Each gets a translator into one event stream, plus a table declaring what that engine can do. The test of the abstraction came with the second and third engines: the core did not change. Switching engines mid-conversation hands over from the event log mechanically — no model is asked to summarize.
Permissions the OS enforces
Each module ships a manifest, and the app generates its sandbox rules from it. No network unless declared. The home directory is unreadable by default. Secrets stay in the system keychain: a module gets the address of a local relay, and the relay adds the credential on the way out, only to the host the manifest pinned. Neither the module nor the agent ever sees the secret.
Approval that cannot be talked around
An approval card shows the request exactly as the engine sent it; policy can allow or deny, never rewrite. Destructive commands ask in every mode, including full-auto — because full-auto means the app approves instantly, not that the engine skips asking. “Stop everything” kills the processes; it does not go through the model.
Memory that consolidates under guard
Every night a consolidation session proposes changes to memory. It cannot write: it can only propose, and the app does the writing after the guards run. A snapshot is taken first, so a whole night can be rolled back. Guards reject anything that retires more than a quarter of what was there, cites no source, or cites something a stranger wrote. Standing rules can only come from what the owner said.
Skills it cannot game
Skills the agent writes for itself start as drafts, and drafts enter no session. Evaluation runs in the app, not among the agent’s tools, and its result is never returned to the agent: collisions with existing skills, outbound traffic, secrets, dangerous commands, enough evidence. Then the sessions that justified the draft are replayed as regression. A human releases it.
Everything: product definition, architecture, the native macOS app, modules, tests. Generation one went on sale in April 2026 and still sells. Generation two is a from-scratch rewrite, built in 13 days in November 2026.
- Swift 5.10
- SwiftUI
- macOS 14+
- MCP
- ACP
- Claude Code
- Codex
- Keychain
- Vision
- git