Skip to content
At Work

Build an agent harness that runs every AI model in one app

Fable 5 built “Damon”—one Mac app to run all your agents, on the subscriptions you already pay for. Here’s the exact build, step by step.

12 min readVideo tutorial

0
Watch the build, then follow the steps below.

AI agents are everywhere, and it’s chaos: a pile of chat windows across Telegram, Slack, Cursor, and Codex, with no system to any of it. This tutorial fixes that. You’ll build one app that runs any agent on any model — all on the subscriptions you already pay for — and Fable 5 does the building. You just steer.

What you’ll build

  • A rail of categories (e.g. YouTube) with agents under each
  • Terminal tabs across the top — each its own live session, its own repo
  • Any model: Claude, GPT/Codex, or open-source (Kimi, MiniMax, GLM) via OpenRouter
  • Self-improving agent memory, forked from Hermes
  • A downloadable Mac app you can hand to anyone

Before you start

  • Claude Code with Fable 5 (run it in Cursor or any terminal: /model fable)
  • An OpenRouter account + API key (for the open-source models)
  • A GitHub account (to publish the finished app)

Sketch the harness and write the brief

Before you touch Fable, get the shape clear. The whole idea: a rail of categories on the left, agents under each, and terminal tabs across the top like Chrome tabs — each tab a live session wired to a model. Look at the open-source ADEs (Superset, and the Conductor interface) for layout, then write a short brief describing exactly that. Sketch it by hand first; even chicken scratch works.

Prompt Fable to build the first mockup

Open a session with /model fable, paste your brief, and point it at an open-source repo to start from. Feed it a screenshot of an interface you like (Conductor) so it matches the layout. Here is the exact prompt that produced the first working mockup:

Prompt · paste into Fable
I'm building my own ADE — an agentic development environment — for how I work. I run agents for everything: writing, content, and coding. I want one app where all of them live. This is a fresh repo; my hand-drawn mockup is at mock/IMG_7232.jpeg — use it as the layout reference.

Start from the Superset codebase (github.com/superset-sh/superset) — it's the closest to this. Pull the memory system from Hermes (github.com/NousResearch/hermes-agent). I like how Conductor (conductor.build) does its tabs, but it's not open source — so I'm giving you screenshots of it. Match the tab layout and feel from those.

Here's how Superset and Conductor work — they're nearly the same — and what I want to change:

They each have a left rail of workspaces/projects, each one a repo in its own git worktree. Inside a workspace you get tabs, and each tab is a terminal pane where you talk to a CLI coding agent (Claude Code, Codex), plus a changes/diff panel on the right. Tabs can auto-launch an agent on open.

Keep that terminal-tab core, but restructure it:
- Make the left rail two levels: categories at the top (each with a profile photo) — like YouTube, or a coding project — and under each category, named agents (each with a name + profile photo). An agent is basically Superset's "workspace" — its own repo/worktree and its own skills.
- When I select an agent, the tabs across the top are sessions of THAT agent — each tab a terminal running the same agent, so I can have three going at once. NOT split by model the way Superset does.
- Keep the terminal panes (chat with the agent right in the terminal) and the changes panel.
- Agents run Claude Code and Codex by default; let me connect OpenRouter for open-source models.
- Give each agent a Hermes-style memory system out of the box (MEMORY.md / USER.md + providers).

Then onboarding (reuse the new-project flow): a new user creates a category and picks a profile photo, then adds agents under it (name + photo), and that builds the rails on the left and tabs on top. Wrap it in a single one-command install.

For the build itself, use the fable-orchestration skill in this repo (.claude/skills/fable-orchestration) — you're the architect: plan and direct, and hand the actual coding to Opus 4.8 agents. But start with the UI only — before you build anything real, give me a clickable mockup of this layout (the two-level rail, the agent tabs, a terminal pane) so I can react to it. Don't wire up the backend yet.

React, then give one round of feedback

Open the mockup, click around, and be blunt about what’s wrong. The first pass will have junk: stray emojis, a light mode you didn’t ask for, panels you don’t need, and — critically — a fake terminal that isn’t wired to a real CLI. Hand it all back at once:

Prompt · feedback pass
Okay, this isn't bad. However, there's some things that are just superfluous, like setup, run, terminal — we don't need. Of course, get rid of those emojis. Absolutely no emojis, ban emojis from everything. What I want instead of emojis is an ability to literally upload a profile photo for each agent.

Agent files, that's a good touch — all files is good. You haven't actually connected this, I'm assuming just because it's a mock-up, but it's not actually connected to the CLI, right? It needs to be connected to the CLI so we can access all of this, whether it's Claude Code or Codex or OpenCode or any of those.

We don't need the path at the bottom — that seems unnecessary. We don't need choosing the model picker. It's literally just terminal windows that you can pull open.

And when I go light mode, it doesn't change the actual chat window color — because it's not a true terminal. You're going to have to factor that in with light mode as well, and figure out how to create the terminal wrapper here and start Claude Code (claude --dangerously-skip-permissions), Codex (bypass approvals), etc.

Turn the mockup into a real Mac app

Once the layout’s approved, promote it from a browser mockup to a proper desktop app. Fable spawns a fleet of sub-agents and does the port — slow but thorough. (This is where the app got its name: Damon, a play on daemon, the background process that quietly does your work.)

Prompt · build the app
All approved. Now build this out into a proper Mac application (Electron). Migrate the mockup over and run the install yourself when it’s ready.

Add every model, not just Claude

Right now it only runs Claude. The whole point is any model. Add a model picker under the New Tab button and connect the open-source models through a single OpenRouter API key — it just points the Claude Code harness at OpenRouter’s base URL with your key.

Prompt · models & OpenRouter
All right, this is looking good. Everything is approved.

Now what I want to do is have an ability to add my ChatGPT subscription as well, and log into — I guess it would technically be Codex — and use GPT-5.5 within this, as well as any open source model.

I don't know exactly how we can set it up with these different open source models. I'm assuming the easiest way is through an OpenRouter API key.

But I want an ability to, when I open up the application and press that new tab button, below the tabs there should be an ability to select: Claude, of course, then the OpenAI logo, then some popular open source models like Kimi K2, MiniMax M3, and GLM 5.2, with their logos as well. So I can just click those and it will automatically open a session with that model.

To get those open source models, the easiest way is to use an OpenRouter API key and we can just select all of these. I'll let you be the judge of all of this. Go ahead and spawn agents and do this next.

Give the agents memory

Close a tab and the agent forgets everything. Fix that with proper agent files — and don’t reinvent them. Hermes already has the best open-source agent memory, so fork its structure straight over: an agents.md (who the agent is), a memory.md it updates after every session, and the self-improving loop between them.

Prompt · agent memory
Perfect — all approved.

Now what I need is for us to build out agents files: agents.md, a memory.md, and anything else that Hermes does.

I need you to go through the Hermes GitHub repo, determine how they have their agents self-improving, and then borrow Hermes and bring it right over.

Ship it as a downloadable app

Last step: make it something anyone can install. Have Fable strip the secret keys, clean up the repo, write a walkthrough, and package a signed Mac build. Then it’s a drag-into-Applications DMG with the same simple onboarding.

That’s the whole harness. You started with a sketch and ended with a Mac app that runs your entire team of agents — any model, all in one place, on the subscriptions you already have.

Prompt · publish
Make this a public GitHub repo people can download. Strip ALL secret keys, organize it, write a walkthrough guide, and package it as a signed Electron DMG. Keep the same simple onboarding: create categories, create agents, add profile photos.

What did you think of this post?

Comments

Sign in to join the conversation.

You might also like.

Articles, builds, skills and tools on the same idea.
Search everything

AI FOR MORTALS.

Your daily AI edge that will make everyone wonder how you do it all.

Every weekday, the practical AI updates that matter, and exactly what to do with them.

The latest in AI, in plain English. Free, every weekday.