Ari’s Space*   est. 2026
Skip to content
ari*s space[ a. ]
← Libraryworkflows / 2026-06-13

Fable made me start using Codex

In a June 2026 build, Fable held the brief while Codex, Kimi, MiniMax M3 and other workers took defined jobs. The routing, fresh checks and stopping rules made the arrangement useful.

7 parts / Hover to explore. Click to read.

In a June 2026 build, Fable held the brief while Codex, Kimi, MiniMax M3 and other workers took defined jobs. The routing, fresh checks and stopping rules made the arrangement useful.

Seat: brief + judgement
          | route by job
          v
     worker reads plan
          | one slice
     saved result -> exit
          |
      fresh-context audit
          |
  accept / retry / escalate
The historical setup routed work by its needs and checked returns before merging. Its retry rule was three retries after the initial attempt, then human escalation; publication remained human.
Context Pack (for agents)
A System 7 style desktop with four model windows assigned different kinds of work
Four lanes from the June 2026 setup. The assignments describe that system.

Fable made me start using Codex. More precisely, it helped me use Claude, Codex, Kimi and MiniMax M3 together.

In my June 2026 setup, Fable could hold the brief and work out where each job belonged. That made it more useful as the seat than as the worker for every task. It was the first arrangement that felt this straightforward to me.

The infrastructure mattered. A model name at the top of a diagram doesn't make the rest coordinate itself.

Match the job before choosing the worker

These were the four visible lanes: Claude/Fable for orchestration, judgement and long context; Codex for heavy code; Kimi for long-video understanding; MiniMax M3 for looping builds.

The exercise below asks you to reconstruct that reported matrix. A match means it fits this example, not that the model is the permanent best choice for every job of that kind.

MODEL MATRIX

Select a task chip, then match the reported June 2026 matrix.

This example has fixed matches. Choose and verify workers for your own tasks.
One orchestrator seat routes tasks outward to four model lanes while workers execute
The seat holds the brief and routes the labour. Workers return evidence.
Separate model apps compared with one desktop that routes tasks to assigned workers
The coordination comes from the surrounding workspace and its routing rules.

Turn routing on in the illustration to see jobs move into their assigned lanes. It demonstrates the arrangement; it isn't running models or measuring their throughput.

TASK ROUTER — Chooser
ROUTING
INBOX
waiting...
CLAUDE
Judgement call
empty
CODEX
Heavy code
empty
KIMI
Long video
empty
M3
Looping build
empty
Queued: 0 filesThe seat routes. It does not execute.

Keep one place for judgement

Everything arrives at the seat. Claude holds the context, taste and judgement calls while workers do the implementation labour.

First classify the task: a heavy code build, a long video, a job needing repeated passes or a decision. Then choose the lane. Small local models handle memory and retrieval so relevant context is ready for the next task.

Briefs go out as files and results come back as files. I don't need a second conversation window for every worker. Before anything merges, a fresh-context audit checks the result without the history of building it. Publication always needs the human.

This is the scrubbed routing contract from that setup:

route:
  heavy-code: codex
  long-video: kimi
  looping-build: minimax-m3
  orchestration-and-judgement: claude
  memory-and-retrieval: local-models
gates:
  audit: fresh context, before anything merges
  publish: human, always

Give each loop a fresh start

The looping worker reads the plan from disk, does one slice, writes its result back and exits. The next pass starts with a clean conversation and reads the saved work.

It has to inspect what was built. Files make the state available across passes, but a previous worker's confident report can still be wrong. The check is against the actual result and the plan.

The loop ends when the plan is complete or a gate stops it. A cheaper model can be a useful worker when the slice is within its capability and the surrounding checks are strong enough. That is something to establish through results.

What the two-day account showed

My briefs, plans, outputs, audits and Cortex links were already files. Fable could follow those links and route the next task without pulling the whole workspace into one conversation.

The seat specified this page. A Claude Sonnet worker built its components and diagrams and returned a green build. The seat did not open the editor. That is evidence of this workflow, rather than proof that one model can coordinate any project effortlessly.

The reported two days used these roles:

WorkModel usedReason in this setup
Turn the brief into routed jobsFableHold the thread and reason about the task shape
Build this page and return a green buildClaude SonnetExecute a contained component and diagram build
Plan hard builds and synthesise deep problemsOpus 4.8Reserve the slower, careful lane for planning
Finish a heavy implementationCodexClose work that a cheaper lane hadn't resolved
Run looping builds and audit passesMiniMax M3Keep repeated bounded passes affordable
Read a large body of material for a verdictKimiUse the large-context lane available in the setup

Local models also handled memory and retrieval. These are the roles from that account, not a current ranking or a claim that those names describe today's available models.

Keep the failures in the receipt

Two cheaper passes struggled with the same implementation. Codex took the next pass and finished it. That changed the assignment because of the result, rather than loyalty to a particular lane.

The audit loop exposed a different problem. A briefing bug prevented the checker from writing its verdict, so the system launched the same audit again. It ran about ten times before the problem was caught.

A Sonnet worker found the cause, added a cap and wrote tests that night. The rule became three retries, then escalation to me. That means retries after the initial attempt, not a claim of three total attempts.

A better stopping rule fixed the repeat. Swapping in a more expensive model would not have repaired the missing verdict path by itself.

What was planned next

At the time, the routing matrix and looping build system were planned for an ARI-OS update. This account doesn't establish that the public installer now contains the complete private setup.

The part worth carrying forward is the design: a clear brief, work routed by its needs, saved results, independent checks and a route back to the human when the system cannot finish.

The models can change. Keep the discipline around the work.

[ comments ]

guests welcome. members show first in the list

no comments yet. start the thread_

1 / 9