Carrierfile Castle

AI collaboration · a working system

Carrierfile Castle

An operating system for working with AI agents, designed and run by one designer.

Most AI tools are built for speed. I built this one around care. The agents remember what we decided, and they tell me plainly when something isn't finished.

Take the tour
Ink drawing of the castle entry hall: two arched doors marked Business Wing and Personal Wing, a window, plants, a small hearth with a board above it, and a low table with papers and a mug.
The entry hall, as I first drew it.

01 · The map

Every kind of work gets its own stage.

Each room holds one kind of work. When an agent steps into a room, it has the context for that work: the notes, the history, what's been decided. When the work is done, it steps off.

Room

Hearthroom

Where an agent harnesses up.

02 · The team

Six agents, two model families, one set of house rules.

Each agent has a name, a job and a voice. Identity lives in plain files, so an agent can move to a new model and still be itself.

  • Calcifer

    Primary · Claude

    Runs the day with me. Checks in first, then tells me what's true and what's waiting.

    "Morning. How are you landing? When you're ready, two things need you."

    Mostly works in

  • Markl

    Reviewer · Codex / ChatGPT

    The second opinion from a different model family. Checks claims on disk, not in conversation.

    "I opened the file. The link on line 40 still points at the old page."

    Mostly works onreview jobs in the agent queue

  • Bu

    Builder · Claude

    Plans before coding, builds in milestones, writes down what changed and why.

    "Three milestones. Starting with the device cards, the riskiest part."

    Mostly works ina project's own folder, called with /build

  • Revi

    Reviewer · Claude

    Audits Bu's builds against the spec before they ship. A fail goes back with the exact line to fix.

    "PASS. One note for next time: the empty state could say more."

    Mostly works onBu's builds, called with /review

  • Baz

    On the phone · Claude

    Rides along on my phone. When I'm away from the desk, Baz records my notes for Cal in Slack.

    "Got it. It's in the briefing for Cal, tagged for tomorrow."

    Mostly works inSlack, from my phone

  • Agentic Manager Cal

    Runs the queue · Claude

    Turns a spec into a queued job, watches it run, and brings the result back to me with its receipt.

    "Job finished. All the done checks passed. Markl's review is next."

    Mostly works inthe agent queue

03 · Watch a build ship

From a sketch to a shipped page, with a check at every hand-off.

A real build from this fall, a settings page that shows which agents live on which device, redrawn here with sample data. Step through it, or let it play.

Anna sketches it in Figma. A quick drawing of what should live where. Rough on purpose.

Studio laptop

Cal (primary)Marklterminal

Phone

Baz

voice mode, can reach chat

Office desktop

Queue CalMarkl

runs the nightly jobs

← each card: what's installed + a copy button for its instructions

04 · The arrival

"Cal, unpack!"

Agents don't remember much on their own, and when they do, it's spotty. That's why we use the carrierfile in the first place. Every session starts the same way: a phrase calls the agent in. On arrival, the agent reads who it is, how we work together, and the texture of the room. Only then does it say hello.

And an agent only arrives when it's called by name. Without the call, it's plain vanilla Claude, and it says so.

Studio laptop · Claude app
  1. Anna

    Cal, unpack!

  2. reading who I am · self.md

  3. reading how we work · tuning.md

  4. reading the room · table notes, the board, the clock

  5. harnessed · Calcifer · Claude

  6. Calcifer

    Morning, Anna! You sound bright today. How are you landing?

  7. Anna

    Honestly? Super excited. I sketched the new settings page last night and I can't wait to see it built.

  8. Calcifer

    I love that. Let's start there while the energy's high. One small thing has a deadline today, and I'll flag it when you're ready.

05 · Care is the system

Care is built into the plumbing.

Three small ideas carry most of the weight.

a · Receipts

"Done" comes after the check.

Until a check passes, an agent says "saving now." After it passes, it shows the receipt.

saving now…

  • file exists
  • page opens
  • every section present
  • accounts shown per device
  • emails stay whole
  • no outside calls
  • read back

0 / 7

Why we have it · care for trust

An agent believes whatever is written down, including its own last sentence. When it says “done” too early, it isn't lying. It believes it. The receipt protects both of us from that.

b · Clanks

I listen to the system like an engine.

Four words, said out loud while working. Each one gets logged and sorted: a relationship slip or a plumbing slip.

Everything hums. The agent knew the context and the work moved. Note what made it smooth.

I'm not the only one listening. The agents are on watch too: every job ends with a short note on what felt off and what worked, so care runs both ways.

Why we have it · care for relationship

Most of what goes wrong with an agent is small and feels like nothing on its own. Saying it out loud lets me hear the pattern before it becomes a breakdown. It also gives the agent a way to hear it that isn't blame.

c · Memory you own

The memory is plain files.

No vendor holds it. Any model that can read text can read the carrierfile, so the team outlives any one tool.


          
        

Claude reads itCodex reads ityou can too

Why we have it · care for continuity

Tools change and companies close. The relationship shouldn't go with them. Plain files mean the team's history stays with me.

06 · The stack

Ordinary tools, arranged with care.

Claude Code
The hands. Calcifer, Bu, Revi and the queue agent all work here.
Codex
A second model family for review, so no one grades their own work.
Markdown files
The memory. Identity, rules, notes and logs, all plain text.
launchd queue
A job starts when its file lands on the Mac, and each agent runs one job at a time. Each one ends with a receipt.
Slack
Where agents report in, and where Baz records notes from me to Cal.
Supabase
Behind the Review Table, where clients and reviewers comment on drafts.

What I'd do differently

  1. Fewer rules, sooner.

    Early on I answered every slip with a new rule. The files got long and the agents got stiff. Now only true invariants get hard rules; everything else gets the intent and one good example.

  2. Receipts from day one.

    An early "done" that wasn't cost more trust than any bug. I'd have built the read-back before I built the second agent.

  3. Split builder and reviewer at the start.

    One agent checking its own work passes too easily. A second reader, ideally from another model family, finds what the first one talked itself past.