Ethan. Email me
02 · Flagship · Since 2025-10

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.

  • In daily use

Second generation · runs every day

In three lines
Problem

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.

Decision

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.

Result

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.

By the numbers
13
days from first commit
235
commits
255
automated tests
3
engines
8
modules
The product, on screen

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.

Every step lands in an append-only, hash-chained log in her folder — including the engine switch itself.
Every step lands in an append-only, hash-chained log in her folder — including the engine switch itself.
A module declares what it needs. This one asked for a single file, so its sandbox has no network at all.
A module declares what it needs. This one asked for a single file, so its sandbox has no network at all.
This module needs a GitHub token. The real value stays in the Keychain; the module only ever reaches a local relay and never sees it.
This module needs a GitHub token. The real value stays in the Keychain; the module only ever reaches a local relay and never sees it.
Before a release goes out she sees the exact request the engine sent. The original, not a summary.
Before a release goes out she sees the exact request the engine sent. The original, not a summary.
Destructive commands always ask, in every approval mode, and cannot be waved through for the session.
Destructive commands always ask, in every approval mode, and cannot be waved through for the session.
The night report. Three proposed memories were rejected by the guards: one sourced from a stranger’s comment, one with no source, one rule the owner never stated.
The night report. Three proposed memories were rejected by the guards: one sourced from a stranger’s comment, one with no source, one rule the owner never stated.
Skills the agent drafts for itself. One is ready for review; one was blocked because its body pipes a download into a shell.
Skills the agent drafts for itself. One is ready for review; one was blocked because its body pipes a download into a shell.
A Product judgment

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.

B Engineering
You

Type, approve, review the night report.

Soul Engine app · macOS
  1. Guards
  2. Policy
  3. 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.

Engine · swappable

Claude Code · Codex · any ACP agent

The model and the tools run here.

Modules · sandboxed

Manifest → sandbox rules. No network unless declared. Never holds a secret.

Your folder · a git repository you own
  • 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.

Write-back path 1 · memory

Nightly proposal → guards → night report → you

Write-back path 2 · skills

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.

What I did

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