# Develop at Idea Velocity

Jeffrey Lee-Chan, Snapchat

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/9arM9b7JgOo-develop-at-idea-velocity) · [Video](https://www.youtube.com/watch?v=9arM9b7JgOo)

## Develop at Idea Velocity

Short requests become useful engineering work when agents remember intent, delegate implementation, and return evidence—while people manage testing, reliability, and cost.

Basic familiarity with Git branches, pull requests, automated tests, and coding agents will help you follow the workflow.

### From a brief request to verified work

[0:01](https://www.youtube.com/watch?v=9arM9b7JgOo&t=1s)

How do you get an agent ready to accept useful work—and keep an experimental change from breaking it? Jeffrey Lee-Chan opens with two workshop tracks: installing OpenClaw for newcomers and trying a second instance as a staging environment. The second track is experimental: he has not finished getting the instances working together and invites participants to help debug it. The planned rhythm alternates setup, Q&A, advanced topics, and short discussions.

Once the system is running, the everyday interaction is much smaller than a detailed coding prompt. Jeffrey estimates that his setup works roughly 70% of the time, an informal estimate without a defined task set or success criterion. A brief Slack request can refer to the skeptic agent, his custom code review tool, because OpenClaw remembers earlier requests. Asking it to fix that agent does not require explaining the project again. **Persistent context makes a short instruction meaningful.**

Implementation then fans out to multiple agents using **Git worktrees**, which give parallel workers separate working directories. For two independent tasks, the basic Git setup can look like this:

```bash
git worktree add -b fix/skeptic-agent ../skeptic-agent-work HEAD
git worktree add -b fix/review-timeout ../review-timeout-work HEAD
git worktree list
```

Each worker can operate in its assigned directory without sharing another worker’s checked-out files. The workflow slide places these worktrees between context and memory on one side and CI, review, and proof on the other. Jeffrey briefly mentions CI integration, then shows that the loop still needs debugging: a timeout can prompt the simple instruction to give the operation longer.

Other interventions are managerial: ask what the priorities are, inspect what is underway, and tell an agent that reports completion to run the test. Those responses are not elaborate prompts. Their routine nature suggests Jeffrey’s next automation target: another agent could supply some of the reminders he currently provides himself. The aim is to remove repeated supervision while retaining the checks that make completion credible.

![How It Works slide with five linked circles labeled Describe, Context + Memory, Agent Worktrees, CI & Review, and Proof-First.](https://ai.engineer/api/talk-essay-media/27c90c51837a8174153ab54070964376d69c625c670aed0e2e190898654562a5)

The workflow moves from describing a task through context, agent worktrees, CI and review, and proof.

### Communication, managers, and coding workers

[3:17](https://www.youtube.com/watch?v=9arM9b7JgOo&t=197s)

OpenClaw matters here as a way of organizing interaction, beyond any particular repository. The first requirement is **frictionless communication**: reaching the AI should not require opening a remote desktop or sitting down at a particular computer. Jeffrey points to Claude Cowork as another product addressing a similar interaction problem. When sending a request is easy, work can begin at the moment the idea occurs.

The next question is how much direct control to retain. Jeffrey describes a personally permissive approach, with OpenClaw orchestrator managers supervising workers. When he wants closer control, he uses [cmux](https://github.com/manaflow-ai/cmux), a terminal suited to parallel AI development. Beneath that management layer, his fork of [Agent Orchestrator](https://github.com/jleechanorg/agent-orchestrator) runs the workers. Those workers run Claude Code, which can launch agents and subagents of its own.

The stack therefore separates several responsibilities:

| Layer | Responsibility |
|---|---|
| OpenClaw | Conversational entry point and remembered context |
| Managers or cmux sessions | Supervision and direction |
| Agent Orchestrator workers | Parallel coding sessions |
| Claude Code agents and subagents | Implementation and delegated subtasks |

Jeffrey actively changes the orchestration layers above Claude Code. Once execution reaches Claude Code and its internal delegation, he is primarily using an existing system rather than building that part of the stack himself.

![Agent stack slide listing OpenClaw, agent managers, Agent Orchestrator workers, managed agents, and subagents beside a layered blue illustration.](https://ai.engineer/api/talk-essay-media/f3e1b5a5f3b9342f8083dc294e2e5a49642716284732e016d4dd5de3d38e09ec)

The agent stack separates OpenClaw, managers, coding workers, and subagents.

### Separate intent from implementation, then demand evidence

[5:06](https://www.youtube.com/watch?v=9arM9b7JgOo&t=306s)

An attendee asks why OpenClaw is necessary instead of using Claude directly. Jeffrey’s answer is **specialization of context**. The manager should make decisions from the specification, goals, and history of the request. A coding agent needs a different body of information: `CLAUDE.md`, skills, and MCP integrations tell it how to perform the work.

Jeffrey illustrates the distinction by imagining implementation material already occupying 25% of a coding agent’s context; this is a hypothetical, not a measurement. The manager’s attention should instead go toward connecting his Slack messages from the preceding two weeks into a reasonable specification. Separating the contexts gives one agent room to decide what the work means while another concentrates on how to implement it.

Testing then needs to cover both behavior and presentation. Player actions can be exercised without a browser through MCP, commonly carrying JSON, or through HTTP. The transport is secondary to the coverage: can the test perform everything a player can do? CSS or JavaScript checks can cover additional behavior, with browser and visual tests handling what remains visible only through the interface. The useful diagnostic question is which failures actually required a human to resolve them.

That boundary changes as agents improve. Jeffrey reports revisiting it over monthly or quarterly intervals: browser tasks that were troublesome six to twelve months earlier now work more reliably for him. Finding a popup and entering a password is his concrete example of a formerly difficult interaction. He also promises links in place of the slash-command references so participants can follow the workflow.

### Reactive stories and multi-model answers

[7:43](https://www.youtube.com/watch?v=9arM9b7JgOo&t=463s)

The first product demonstration is an AI role-playing game, represented in Jeffrey’s [project directory](https://github.com/jleechanorg) as WorldAI/WorldArchitect.AI. A player starts with a default campaign, chooses options, and gets an avatar. The game builds a custom world that responds to freeform speech and actions with further story.

The distinguishing mechanism is a D&D rules system. A story played directly in Gemini Chat or ChatGPT can let the player win too easily; this game uses dice rolls to determine whether an attempted action succeeds. The player still has freedom to propose an action, but the narrative must account for a rule-governed outcome. That makes failure part of the game rather than something the conversational model can simply smooth away.

The second demonstration, Consensus ML, automates a research habit. Jeffrey would ask several models the same question, copy their answers, and paste them into one model for synthesis. The website performs that collection-and-synthesis workflow for him. Workshop planning is the example query. He generally prefers these synthesized answers to asking one model alone; the demonstration presents his working preference rather than a measured quality comparison.

### Manage the work without inheriting the worker’s conclusion

[9:22](https://www.youtube.com/watch?v=9arM9b7JgOo&t=562s)

Back in the terminal, the instructions remain short: get the status, then add to the latest pull request. cmux’s vertical tabs help Jeffrey keep track of sessions that would be easier to lose in a horizontal strip. Completion notifications turn monitoring into a queue of items needing attention: he can work elsewhere until a session asks him to look.

He uses these terminal sessions more as managers than as coders. His concern with working directly alongside a coding agent is that it tends to present its own changes as successful. A manager with different context can make a different decision about the same work.

PR `294` supplies the concrete example. The manager recommends closing it because another pull request should supersede it. Jeffrey contrasts that recommendation with what he expects from a worker immersed in the original PR: advocacy for merging its own changes. The observed outcome is the manager’s recommendation, not a demonstrated closure. **Different context can support a different judgment about whether work should ship.**

One session is still compacting its context, so Jeffrey moves on rather than waiting. Notifications will bring him back when it needs attention. He reports that cmux has improved his efficiency, with the benefit coming from organizing parallel sessions and reducing the need to watch each one continuously.

### Make delegated and remote work visible

[10:59](https://www.youtube.com/watch?v=9arM9b7JgOo&t=659s)

Jeffrey invites Austin, introduced as one of cmux’s creators, to describe recent additions, noting that his own endorsement is unpaid. Austin describes a [Claude Code Teams integration](https://cmux.com/docs/agent-integrations/claude-code-teams) that automatically opens terminals so users can see delegated agents working. In the current documentation, those team members are called teammates and appear in native cmux splits; they are distinct from the generic subagents discussed earlier in the stack.

Austin also describes native cmux SSH for remote work, including connections involving Tailscale. Running OpenClaw on remote Mac Minis is one example. The contribution ends with an invitation to send bugs, feedback, and feature requests. A brief setup exchange follows: downloading an app is suggested as a convenient way for an attendee to regain access and finish setup.

### Isolation and staging solve different problems

[12:47](https://www.youtube.com/watch?v=9arM9b7JgOo&t=767s)

Aaron, an attendee who already has OpenClaw installed but describes himself as nontechnical, asks about sandbox token usage. Jeffrey initially answers in terms of isolation: he does not expect sandboxing itself to increase token usage and recommends keeping it if it works. He says his own unsandboxed use has had no incident so far, while adding that he would sandbox an external bot. That personal experience does not establish that unsandboxed execution is safe.

Aaron then explains the actual failure: testing or changing a model can take his OpenClaw instance down, leaving him to recover it. Jeffrey recognizes that they mean different things by sandbox. Ordinary sandboxing means Docker or another isolated execution environment; Aaron wants the separate staging instance from the workshop instructions.

| Mechanism | What it separates | Problem addressed |
|---|---|---|
| Isolation sandbox | Execution from the surrounding system | Exposure to agent actions |
| Staging instance | Experimental changes from the production instance | Disruption while testing changes |

A second instance is therefore not just another name for an isolation boundary. It provides somewhere else to test before changing the instance relied on for everyday work.

Sending the same work to both OpenClaw instances could double token usage. Jeffrey proposes a more selective sequence:

1. Develop the change locally.
2. Run integration tests against the staging instance.
3. Once the checks pass, merge the code.
4. Deploy the merged change to the production instance.

This adds test work without requiring every production task to run twice. Usage would still increase, with greater reliability as the intended benefit.

The proposed workflow is not yet a completed demonstration. Jeffrey has written instructions and started setting it up, but the two instances are competing with each other and need debugging. He offers it as an experiment especially suited to advanced participants, while welcoming others who want to try. The unresolved coordination matters: merely starting a second agent does not establish a reliable staging process.

### The operating limit is also the budget

[14:41](https://www.youtube.com/watch?v=9arM9b7JgOo&t=881s)

The final question asks whether Jeffrey uses a default orchestrator model or chooses models by task. He mostly uses **GPT-5.3-Codex**, which he calls Codex 5.3. Jeffrey reports that [**GPT-5.4**](https://openai.com/index/introducing-gpt-5-4/) used more tokens in his workflow. This is his experience, without matched task measurements or specified settings. Even with his preferred model, he runs through his available allowance quickly enough to consider changing his approach.

When the allowance gets low, he switches to **MiniMax**. He finds it less capable but sufficient to get work done, and describes the choice as driven more by money than preference. The practical constraint on greater autonomy is therefore not only whether agents can complete the work, but whether their ongoing use fits the available budget.

## Resources

- [Jeffrey's Agent Orchestrator fork](https://github.com/jleechanorg/agent-orchestrator) — Framework for supervising parallel coding agents with isolated worktrees and PR, review, and CI feedback loops.
- [cmux](https://github.com/manaflow-ai/cmux) — A native macOS terminal with vertical workspace tabs, agent notifications, and programmable controls.
- [Claude Code Teams in cmux](https://cmux.com/docs/agent-integrations/claude-code-teams) — Instructions for displaying Claude Code teammates in native cmux splits with metadata and notifications.
- [OpenClaw sandboxing documentation](https://docs.openclaw.ai/gateway/sandboxing) — Current guidance on isolating tool execution, workspace access, and sandbox security limits.
- [Jeffrey's experimental orchestration harness](https://github.com/jleechanorg/jleechanbrain) — A prototype connecting conversational requests, persistent context, parallel workers, and engineering evidence.
- [WorldAI and Consensus ML project overview](https://github.com/jleechanorg) — An overview of Jeffrey's AI storytelling, multi-model consultation, and development automation projects.
- [GPT-5.4 launch details](https://openai.com/index/introducing-gpt-5-4/) — OpenAI's launch account of GPT-5.4 capabilities, evaluation conditions, pricing, and Codex usage rules.
- [Engineering Management In The Age Of AI](https://www.stellarwork.com/audio-transmissions/engineering-management-in-the-age-of-ai) — A companion interview with Jeffrey about engineering management, AI tooling, and development bottlenecks.

## Slides

### How It Works

A Slack request moves through remembered context, parallel agent worktrees, CI and review, and proof-first verification. Lee-Chan estimates the setup works about 70% of the time; sometimes it needs debugging.

[1:08](https://www.youtube.com/watch?v=9arM9b7JgOo&t=68s) [Five-stage workflow: describe, context and memory, agent worktrees, CI and review, and proof-first.](https://assets.ai.engineer/sites/aiecode2025/sha256/04aac8cca6c2464a70018f84a4bbe793051322b4f715a7619d198eb1678ea142.webp)

How It Works

A single natural-language message in Slack triggers the full autonomous pipeline — from intent to green checks.

Describe
Context + Memory
Agent Worktrees
CI & Review
Proof-First

Each stage is fully automated and evidence-backed — no manual re-entry of context, no babysitting CI, no chasing reviewers.

Interface text:
[illegible] LEE-CHAN

### Live Demo

The demo introduces the pipeline from Slack intent to green checks. The speaker notes that brief requests can work, but sometimes require debugging.

[2:00](https://www.youtube.com/watch?v=9arM9b7JgOo&t=120s) [Live demo section introducing the pipeline from Slack intent to green checks.](https://assets.ai.engineer/sites/aiecode2025/sha256/b40ad62d29204934e683ab78dc26d0ab9241fac8a2cfd7b59c697acf2f91830b.webp)

SECTION

LIVE DEMO

Pipeline in action — Slack intent to green checks

### What is OpenClaw?

OpenClaw is presented as a central AI connected to messaging, data sources and memory. The diagram places orchestrator agents and terminals between OpenClaw and coding agents.

[3:15](https://www.youtube.com/watch?v=9arM9b7JgOo&t=195s) [OpenClaw concepts include central AI, communication, access to services and memory, alongside an agent architecture diagram.](https://assets.ai.engineer/sites/aiecode2025/sha256/4cdb5c970609fdab4335021060cd057ee60164089d0e52c5d5026f6d075e55a7.webp)

What is Openclaw?

Central AI
Beyond any particular code or repo the concept is important

Frictionless communication
Slack, WhatsApp, Telegram,

Access to central data sources and services
The more access you give to everything you can access the more powerful ie. Docs, Gmail, Slack

Memory
It remembers what your goals/desires/past actions are ideally replacing more and more of your decisions

OpenClaw - Autonomous AI Coding Architecture

Data Sources & Services
Error Logs
Customer Complaints
Me
Meeting Notes
Memory
[illegible]
Skills

Data Sources & Services
Google Docs
Google Calendar
Slack
Google Calendar
Emails
Database
Slack

OpenClaw
Cmux Terminals + Orchestrator Agents
Claude Code Agent
Codex Agents
Codex Agents
Gemini Agent
Antigravity IDE
Claude Code worktree
Codex
Codex
Sub-agents & Self-Managing Agents
Sub-agents & Self-Managing Agents
Data Sources & Services

Interface text:
[illegible] LEE-CHAN

### Code walkthrough

Introduces a code walkthrough of the multi-agent loop.

[4:05](https://www.youtube.com/watch?v=9arM9b7JgOo&t=245s) [Section slide introducing the multi-agent loop.](https://assets.ai.engineer/sites/aiecode2025/sha256/23c44e0b7950e043cf9ef767ee438c60ce3a94e555c2e6a0ddd43333f9bea27d.webp)

SECTION
CODE WALKTHROUGH
Inside the multi-agent loop

### Agent stack

OpenClaw coordinates managers and workers; Jeff uses cmux terminals when he wants more direct control. Workers can run Claude Code, which can spawn its own agents and subagents.

[4:10](https://www.youtube.com/watch?v=9arM9b7JgOo&t=250s) [A list and diagram show OpenClaw, agent managers, workers, managed agents and subagents.](https://assets.ai.engineer/sites/aiecode2025/sha256/5cbf22895954fc8600369bbc5e86cac957d58ef7a8a381ab4dcb3b3b8f97cc5d.webp)

Agent stack

Jeff stack / open source
1. Openclaw
2. Agent managers
   a. CMUX terminals OR
   b. Agent Orchestrator managers
3. Agent Orchestrator workers (claude code, codex, cursor cli)

Claude code / codex / etc
1. Managed agents (agents managed by above aka claude teams feature)
2. Subagents

Diagram text:
OpenClaw
Cmux Terminals + Orchestrator Agents
Agents
Claude Code
worktree
Codex
Antigravity IDE
Sub-agents & Self-Managing Agents

### Practical outcomes

This section introduces production lessons from WorldAI RPG and Consensus ML.

[6:10](https://www.youtube.com/watch?v=9arM9b7JgOo&t=370s) [Section slide introducing production lessons from WorldAI RPG and Consensus ML.](https://assets.ai.engineer/sites/aiecode2025/sha256/84faa12544ff7976ecacc1cd79acac657c535835fcfe71d48757e9baa97f23c1.webp)

SECTION
PRACTICAL OUTCOMES
WorldAI RPG and Consensus ML — production lessons

### Campaign setup

In the AI RPG demo, the selected Dragon Knight campaign pre-fills a character and a world premise. The form also offers a custom campaign and fields for changing the adventure.

[7:59](https://www.youtube.com/watch?v=9arM9b7JgOo&t=479s) [WorldAI campaign setup with a character, setting, and campaign type.](https://assets.ai.engineer/sites/aiecode2025/sha256/8c2857b954ef3077c6bdc7b859b304646f9c75ccee38ad117500b1197871240e.webp)

Campaign Type

Dragon Knight Campaign
Play as Ser Arion in a morally complex world. Perfect for new players!

Custom Campaign
Create your own unique world and story from scratch.

Campaign Title (Pick anything!)
My Epic Adventure
This helps you identify your campaign in the dashboard.

Character you want to play
Ser Arion
Leave blank for a randomly generated character

Setting/world for your adventure
World of Assiah. Caught between an oath to a ruthless tyrant who enforces a prosperous peace and the call of a chaotic dragon promising true freedom, a young knight must decide whether to slaughter innocents to preserve order or start a war to reclaim the world's soul.
Leave blank for a randomly generated world

Campaign description prompt
Expand

Previous
Step 1 of 4
Next

Interface text:
WorldAI
mvp-site-app-dev-i6xf2p72ka-uc.a.run.app / WorldAI
Openclaw Workshop March
Consensus ML - Multi-mod[illegible]
Openclaw Agent Orchestr[illegible]
claude-commands/.claude[illegible]
smartclaw/docs/openclaw[illegible]
Bookmarks
All Bookmarks
Home
DMs
Activity
Files
Later
More
Admin
Timeline
Antigravity - Settings

### AI expertise options

In the AI RPG setup, the presenter selects a default fantasy world, mechanical precision, and starting companions. He describes a world that responds to the player’s actions with a story.

[8:03](https://www.youtube.com/watch?v=9arM9b7JgOo&t=483s) [WorldAI setup offers default world, mechanical precision, and starting companion options.](https://assets.ai.engineer/sites/aiecode2025/sha256/75b43d8f7ec2474ffc880df665b968600835d706d3e2c029f286596bae4b4ae3.webp)

Start a New Campaign

1 Basics
2 AI Style
3 Avatar
4 Launch

Choose Your AI's Expertise
Select which aspects of storytelling you want enhanced.

Default Fantasy World
Use the Celestial Wars/Assiah setting with rich lore and characters.
☑ Use default world

Mechanical Precision
Rules accuracy, combat mechanics, and game system expertise.
☑ Enable

Starting Companions
Automatically create complementary party members to join your adventure.
☑ Generate companions

Previous
Step 2 of 4
Next

Interface text:
Comet
File  Edit  View  Assistant  History  Bookmarks  Profiles  Tab  Window  Help
Sun Mar 29 5:30 PM
Openclaw Workshop Marc[illegible]
Consensus ML - Multi-mod[illegible]
WorldAI
Openclaw Agent Orchestra[illegible]
claude-commands/.claude
smartclaw/docs/openclaw
Bookmarks  All Bookmarks
Home  DMs  Activity  Files  Later  More  Admin
Antigravity - Settings

### Infrastructure

The infrastructure section covers token costs, model trade-offs, and CMUX terminal logs.

[9:15](https://www.youtube.com/watch?v=9arM9b7JgOo&t=555s) [Infrastructure section slide introducing token costs, model trade-offs, and CMUX terminal logs.](https://assets.ai.engineer/sites/aiecode2025/sha256/b644e1ed41b78d6c5fb824ac7567bf2397821e8fbd6578c1117c2d4f2afc8162.webp)

SECTION
INFRASTRUCTURE

Token costs, model trade-offs, and CMUX terminal logs

### Worker progress and investigation

A manager dispatches a replacement for PR #294 and finds it stuck on hook errors despite code progress. In the other pane, an investigation revises its initial diagnosis of the missing Skeptic worker.

[9:51](https://www.youtube.com/watch?v=9arM9b7JgOo&t=591s) [Two terminal panes show worker progress on the left and investigation output on the right.](https://assets.ai.engineer/sites/aiecode2025/sha256/1541903fa5517965b6098f6b38154a282c9a3fa335dbf1d2213bb39b0ce36217.webp)

Left pane:

PostToolUse:Bash says: AO_SESSION environment variable not set, skipping metadata update

Good news — ao-1544 actually made solid progress despite the hook errors:
- scripts/ao-checks.sh — 590 lines, created (the unified shared checks file)
- scripts/ao-doctor.sh — refactored (862 lines removed, now sources ao-checks.sh)
- packages/cli/scripts/ao-doctor.sh — refactored in sync
- scripts/start-all.sh — 7 lines added (doctor --fix pre-flight)

But it's stuck on hook errors and hasn't committed or pushed. Let me take over — commit, push, and open the PR from the worktree.

Bash(cd ~/.worktrees/agent-orchestrator/ao-1544 && git diff --stat --cached 2>/dev/null; echo "---unstaged---"; git diff --stat 2>/dev/null)
  PreToolUse:Bash hook error
  ---unstaged---
  .claude/metadata-updater.sh | 14 +-
  packages/cli/scripts/ao-doctor.sh | 458 +++---------------------------------
  +5 lines (ctrl+o to expand)
  PostToolUse:Bash says: AO_SESSION environment variable not set, skipping metadata update

Bash(cd ~/.worktrees/agent-orchestrator/ao-1544 && git status --short 2>/dev/null | head -15)
  PreToolUse:Bash hook error
  M .claude/metadata-updater.sh
  M packages/cli/scripts/ao-doctor.sh
  M scripts/ao-doctor.sh
  +2 lines (ctrl+o to expand)
  PostToolUse:Bash says: AO_SESSION environment variable not set, skipping metadata update

Reading 1 file… (ctrl+o to expand)
  ~/.worktrees/agent-orchestrator/ao-1544/scripts/ao-checks.sh

Shimmying… (42s · ↓ 472 tokens)
Tip: Share Claude Code and earn $20 of extra usage · /passes

Right pane:

PostToolUse:Bash says: AO_SESSION environment variable not set, skipping metadata update

Lifecycle-workers are running — but notably no agent-orchestrator lifecycle-worker. There's jleechanclaw, ai-universe-living-blog, and worldai-claw — but the one that would handle skeptic for this repo is missing.

That's the gap. The agent-orchestrator project's lifecycle-worker isn't running, so skeptic triggers for this repo go unprocessed.

Bash(# Check if agent-orchestrator is configured as a project in the active config
  grep -A 2 "agent-orchestrator" ~/.openclaw/agent-orchestrator.yaml 2>/dev/null | h…)
  PreToolUse:Bash hook error
  dataDir: ~/.agent-orchestrator
  worktreeDir: ~/.worktrees
  port: 3020
  +3 lines (ctrl+o to expand)
  PostToolUse:Bash says: AO_SESSION environment variable not set, skipping metadata update

Bash(# Check which projects the running lifecycle-workers cover
  grep [illegible] ~/.openclaw/agent-orchestrator.yaml 2>/dev/null | head -10…)
  PreToolUse:Bash hook error
  runtime: tmux
  agent: claude-code
  workspace: worktree
  +11 lines (ctrl+o to expand)
  PostToolUse:Bash says: AO_SESSION environment variable not set, skipping metadata update

Simmering… (47s · ↓ 770 tokens)

Interface text:
cmux DEV appclick; File; Edit; View; Update Pill; Update Logs; Notifications; Debug; Window; Help
Sun Mar 29 5:37 PM
Open Editor
Tabs: ao: primary; openclaw: main; o: zbot; o2: setup; w2: avatar; lblog: main; ao2: misc; antig: wc; o: primary; ao: antig; w: tails
Claude is waiting for your input; Agent turn complete; THIS IS A DEV BUILD
Left status: Dir: agent-orchestrator | Branch: main (behind 1 +uncommitted); origin/main | ctx 51%; bypass permissions on (shift+tab to cycle)
Right status: Dir: agent-orchestrator | Branch: main (behind 1 +uncommitted); origin/main | ctx 68%; bypass permissions on (shift+tab to cycle)

[10:24](https://www.youtube.com/watch?v=9arM9b7JgOo&t=624s) [A terminal workspace shows worker progress and an investigation of a lifecycle worker.](https://assets.ai.engineer/sites/aiecode2025/sha256/c6a7c8daee5150ed214098a1954085e71d53916ce93b9cff73ae512129ab22d9.webp)

Left pane:

Worker ao-1529 died — session gone, worktree cleaned up, no PR created. Need to respawn. Let me also close #294 as superseded once the new worker gets a PR up.

Bash(ao spawn "PRIORITY: Get a PR up quickly for unified ao-checks.sh. Subsumes PR #294…)
  PreToolUse:Bash hook error
  - Creating session
  ✓ Session ao-1544 created
  Worktree: /Users/jleechan/.worktrees/agent-orchestrator/ao-1544
  +5 lines (ctrl+o to expand)
  (timeout 30s)
  PostToolUse:Bash says: AO_SESSION environment variable not set, skipping metadata update

New worker ao-1544 dispatched. It will:
1. Create the unified ao-checks.sh with all existing + new operational checks
2. Port check_runners() from PR #294
3. Refactor setup.sh + doctor.sh + start-all.sh to use it
4. Open a PR that supersedes #294

Once its PR is up and green, I'll close #294 as superseded. I'll check back on ao-1544's progress shortly.

Baked for 1m 14s

hows the altest pr now

Bash(tmux capture-pane -t [illegible]-ao-1544 -p 2>/dev/null | tail -30)
  PreToolUse:Bash hook error
  Bash(bash scripts/ao-doctor.sh 2>&1 | head -50)
    PreToolUse:Bash hook error
    Running in the background (↓ to manage)
  +23 lines (ctrl+o to expand)
  PostToolUse:Bash says: AO_SESSION environment variable not set, skipping metadata update

Worker is stuck — hitting PreToolUse hook errors on Bash commands and spinning for 22min. Let me check if it made any code progress and unstick it.

Bash(git -C ~/.worktrees/agent-orchestrator/ao-1544 log --oneline -10 2>/dev/null)
  PreToolUse:Bash hook error
  7d9373b8 chore(beads): update doctor/self-healing beads, close resolved skeptic beads
  3256d99a chore(beads): add bd-aysu — auto-detect and recycle idle/zombie
  +16 lines (ctrl+o to expand)

Right pane:

lifecycle-worker. There's jleechanclaw, ai-universe-living-blog, and worldai-claw — but the one that would handle skeptic for this repo is missing.

That's the gap. The agent-orchestrator project's lifecycle-worker isn't running, so skeptic triggers for this repo go unprocessed.

Bash(# Check if agent-orchestrator is configured as a project in the active config
  grep -A 2 "agent-orchestrator" ~/.openclaw/agent-orchestrator.yaml 2>/dev/null | h…)
  PreToolUse:Bash hook error
  dataDir: ~/.agent-orchestrator
  worktreeDir: ~/.worktrees
  port: 3020
  +3 lines (ctrl+o to expand)
  PostToolUse:Bash says: AO_SESSION environment variable not set, skipping metadata update

Bash(# Check which projects the running lifecycle-workers cover
  grep [illegible] ~/.openclaw/agent-orchestrator.yaml 2>/dev/null | head -10…)
  PreToolUse:Bash hook error
  runtime: tmux
  agent: claude-code
  workspace: worktree
  +11 lines (ctrl+o to expand)
  PostToolUse:Bash says: AO_SESSION environment variable not set, skipping metadata update

The agent-orchestrator project IS configured. The lifecycle-worker for jleechanclaw handles all projects in that config. Let me check if it's actually processing agent-orchestrator PRs.

Bash(# Test skeptic locally - does ao skeptic verify work?
  ao skeptic verify -n 303 --dry-run 2>&1 | tail -20)
  Running… (12s · timeout 1m)
  (ctrl+b to run in background)

Simmering… (1m 1s · ↓ 840 tokens)

Interface text:
cmux DEV appclick; File; Edit; View; Update Pill; Update Logs; Notifications; Debug; Window; Help
Sun Mar 29 5:37 PM
Open Editor
Tabs: ao: primary; openclaw: main; o: zbot; o2: setup; w2: avatar; lblog: main; ao2: misc; antig: wc; o: primary; ao: antig; w: tails
Claude is waiting for your input; Agent turn complete; THIS IS A DEV BUILD
Right status: Dir: agent-orchestrator | Branch: main (behind 1 +uncommitted); origin/main | ctx 68%; bypass permissions on (shift+tab to cycle)

## Full transcript

[0:01](https://www.youtube.com/watch?v=9arM9b7JgOo&t=1s) Workshop setup. So, um, [clears throat] there are some people who kind of have, like, never installed OpenClaw, and I wanna kinda get them set up. And then the other people, like, wanna try an experimental thing, which I haven't even fully gotten working, but I think for more advanced people, that'll be cool, um, to get, like, a sort of staging

[0:19](https://www.youtube.com/watch?v=9arM9b7JgOo&t=19s) environment and run two OpenClaws. So I think if I'm not, you know, too busy helping new people set up, then I'll try to help people, like, finish debugging the last part, or maybe someone else will get it.

[0:32](https://www.youtube.com/watch?v=9arM9b7JgOo&t=32s) Then I think, uh, ten minutes Q&A, ten minutes some more advanced topics, and then just more Q&A. And, uh, probably after every five minutes or so, we can do a bit of few minutes of discussion.

[0:44](https://www.youtube.com/watch?v=9arM9b7JgOo&t=44s) So I'll just set some timers to make sure I don't go off track.

[0:49](https://www.youtube.com/watch?v=9arM9b7JgOo&t=49s) All right. Let me start. All right, can everyone see this presentation?

[1:07](https://www.youtube.com/watch?v=9arM9b7JgOo&t=67s) Yes. All right, cool. Yep. So this kind of describes, like, my setup. Um, I'll just keep it really high level for this part where when everything works, you know, maybe, like, seventy percent of the time, you describe your task, and then what's nice is OpenClaw will have, like, context of memory about what you're talking about.

[1:31](https://www.youtube.com/watch?v=9arM9b7JgOo&t=91s) So for example, like, let's say I'm like, "All right, fix this thing."

[1:35](https://www.youtube.com/watch?v=9arM9b7JgOo&t=95s) It's a very brief Slack message, but OpenClaw can remember, like, what I've a-asked it to do before. So for example, I'm working on this thing I'm calling a skeptic agent, and it's a custom code review thing.

[1:47](https://www.youtube.com/watch?v=9arM9b7JgOo&t=107s) But if I'm like, "All right, fix the skeptic agent," or whatever, right, it kind of knows what that is, which is nice. You don't have to re-explain a lot.

[1:55](https://www.youtube.com/watch?v=9arM9b7JgOo&t=115s) Um, I use multiple agents with worktrees. That's very key for parallelization. Uh, CI co-

[2:06](https://www.youtube.com/watch?v=9arM9b7JgOo&t=126s) integration. But you can kind of see, you can talk to it and be pretty brief, and then, you know, usually get reasonable outcomes, but sometimes you'll have to debug it.

[2:16](https://www.youtube.com/watch?v=9arM9b7JgOo&t=136s) So then it's like, all right, there's some timeout thing. I'm like, "Give it a longer timeout," right?

[2:24](https://www.youtube.com/watch?v=9arM9b7JgOo&t=144s) And then I asked it here, like, like, uh, you know, what are the priorities and what we're working on, and I'm reading it here. And then I might have just said, like...

[2:35](https://www.youtube.com/watch?v=9arM9b7JgOo&t=155s) I just made code for it, right? So another interesting thing about this is you can kind of see from, like, um, [clears throat] the types of responses I give, they're not that, like, um, special.

[2:48](https://www.youtube.com/watch?v=9arM9b7JgOo&t=168s) As in I h- I actually think an agent could replace me. So that's kind of what I'm working on right now to, like, get things even more autonomous, you know.

[2:57](https://www.youtube.com/watch?v=9arM9b7JgOo&t=177s) And you, and you'll see this with LLMs, like you're working with them, and they'll be like, "Hey, I've got this thing ready." And I'm like, "Okay, well, run the test," right?

[3:06](https://www.youtube.com/watch?v=9arM9b7JgOo&t=186s) Uh, all right, so I'll show the next slide now. Oops.

[3:17](https://www.youtube.com/watch?v=9arM9b7JgOo&t=197s) Okay. We'll go into some concepts right now, like what is OpenClaw? So I think what's cool about OpenClaw is it's not just about a particular repo or the code, but more of the concept.

[3:28](https://www.youtube.com/watch?v=9arM9b7JgOo&t=208s) So, you know, I've got this cool super diagram, but first concept is frictionless communication. So I know we have other things like Claude Cowork or whatever, but I think they still have a similar concept where it's like, can you, like, easily talk to your AI versus, like, you've got to, um, remote desktop into your computer, or you

[3:50](https://www.youtube.com/watch?v=9arM9b7JgOo&t=230s) have to go sit down. So that kind of enables a certain really higher level of velocity. Um, then I think the central axis is very important. So, you know, there, there's a spectrum.

[4:02](https://www.youtube.com/watch?v=9arM9b7JgOo&t=242s) Like, I kind of go, like, a little more cowboy, and I give it ac-

[4:11](https://www.youtube.com/watch?v=9arM9b7JgOo&t=251s) OpenClaw has these agent orchestrator managers that manage your workers for you. Uh, or sometimes when I want more personal control, I use cmux terminals. So cmux is like a terminal program, but it's pretty good for parallelization and, um, AI development.

[4:27](https://www.youtube.com/watch?v=9arM9b7JgOo&t=267s) Then I use the open source framework that I forked, agent orchestrator, to do the workers. And then once it gets to here, this part is, like, not really controlled by me as much anymore.

[4:37](https://www.youtube.com/watch?v=9arM9b7JgOo&t=277s) Um, so I'm calling them managed agents, but basically, like, you have a worker that runs Claude Code, and Claude Code itself can run agents, so those can have sub-agents.

[4:49](https://www.youtube.com/watch?v=9arM9b7JgOo&t=289s) So once you get to this Claude Code part, right, this part is not exactly my stack, just stuff I use, but this part of the stack I'm changing a lot more.

[4:59](https://www.youtube.com/watch?v=9arM9b7JgOo&t=299s) Um, I'll, I'll pause here to see if anyone has any questions or thoughts.

[5:06](https://www.youtube.com/watch?v=9arM9b7JgOo&t=306s) Um, can you hear me? So I, I have a question. So- Go ahead, yeah. The, the, the real question is, you know, why, why use OpenClaw versus directly use Claude?

[5:17](https://www.youtube.com/watch?v=9arM9b7JgOo&t=317s) So yeah, that's, that's definitely a good question. Um, [clears throat]

[5:21](https://www.youtube.com/watch?v=9arM9b7JgOo&t=321s) the reason I use OpenClaw is specialization. So when OpenClaw makes a decision, I want that context to be more about, like, the spec or the goals or, like, the history of what I want in the task rather than the code.

[5:37](https://www.youtube.com/watch?v=9arM9b7JgOo&t=337s) And you can just imagine this, right? As soon as you open up Claude, it reads CLAUDE.md files, it reads skills, it reads, um,

[5:45](https://www.youtube.com/watch?v=9arM9b7JgOo&t=345s) MCPs. A lot of those things are sort of independent of, like, the actual task. That's more about how to do the task. Um, so imagine, like, twenty-five percent of your context already taken up by implementation versus, like, when you think about OpenClaw, you're like, "Okay-" I wanna think about exactly what I wanna do and how it relates

[6:04](https://www.youtube.com/watch?v=9arM9b7JgOo&t=364s) to all the other Slacks Jeffrey has sent me in the last two weeks, and put it all together and give me, like, a reasonable spec.

[6:16](https://www.youtube.com/watch?v=9arM9b7JgOo&t=376s) Does every single thing a player does, but it does it without a browser, right? So you could use MCP, which usually is JSON or whatever, or HTTP. Doesn't really matter, actually.

[6:26](https://www.youtube.com/watch?v=9arM9b7JgOo&t=386s) And then the final thing is the browser test. So some things, like, are visual. I mean, maybe you could even have CSS tests or JS tests, right? And that kind of goes here.

[6:35](https://www.youtube.com/watch?v=9arM9b7JgOo&t=395s) But then the final thing is visual. So I would recommend you, like, try, um, similar approaches to this and be like, "Okay," like, which problems truly needed that human or not.

[6:45](https://www.youtube.com/watch?v=9arM9b7JgOo&t=405s) Um, and I think what's kind of cool is, like, every quarter or maybe even every month, like, it improves. So before, like, I had to really manually test a lot because, like, you know, this worked fine, right?

[6:58](https://www.youtube.com/watch?v=9arM9b7JgOo&t=418s) But these things didn't work that well with agents, like, last year, like, like a year ago, even six months ago. But now, like, um, agents are pretty good at, like, nailing down a lot of browser tests for me, versus, like, when I started, my agent would have a lot of problems, you know, finding a pop-up and entering

[7:14](https://www.youtube.com/watch?v=9arM9b7JgOo&t=434s) a password. Now, no problem. Um, that was a little long, but does that kind of address the theme of your question? Yeah, I think this is good. Good. Thank you.

[7:23](https://www.youtube.com/watch?v=9arM9b7JgOo&t=443s) Okay. Keep going. Just, just remind me for all these slash commands. I'll put, um, links here instead. All right, cool. Anyone have any other questions related to some of that stuff?

[7:37](https://www.youtube.com/watch?v=9arM9b7JgOo&t=457s) All right. If not, I will go here.

[7:43](https://www.youtube.com/watch?v=9arM9b7JgOo&t=463s) All right, so here's, uh, two websites that I've built. [clears throat]

[7:53](https://www.youtube.com/watch?v=9arM9b7JgOo&t=473s) Yeah, while that loads, I'll show this one.

[7:56](https://www.youtube.com/watch?v=9arM9b7JgOo&t=476s) So this is, like, a AI RPG. Um, what's cool about this is you can... I've got a default campaign, for example. Um, [clears throat] you pick some options. You got a avatar.

[8:09](https://www.youtube.com/watch?v=9arM9b7JgOo&t=489s) And, uh, what's cool about this is it builds a custom world for you that reacts to you, so you can, like, kind of say whatever you want, do whatever you want, you'll get a story back.

[8:19](https://www.youtube.com/watch?v=9arM9b7JgOo&t=499s) Um, the main difference between playing this versus, like, um, you know, you could just always go into Gemini Chat or, or ChatGPT or whatever is that, um, I have, like, a D&D system.

[8:30](https://www.youtube.com/watch?v=9arM9b7JgOo&t=510s) So if you play your own, like, games or novels, like, you kind of just win too much versus, like, with this you'll actually do, like, dice rolls and be like, you know, did the person actually, um...

[8:42](https://www.youtube.com/watch?v=9arM9b7JgOo&t=522s) Did you actually succeed in your action or not?

[8:45](https://www.youtube.com/watch?v=9arM9b7JgOo&t=525s) All right, so while this is going, I'll also, um, show this thing. Yeah, so this is funny. Um, this website is, like, a multi-AI analysis website. Um, so what I found was, like, whenever I was doing research or, or whatever, I would go to multiple models and I would be like, "What's the answer?"

[9:03](https://www.youtube.com/watch?v=9arM9b7JgOo&t=543s) Then I copy and paste them all. I put them into one model. Um, so pretty simple concept, but this does it for you. So usually I like these answers better than, like, asking one model, and I'm like, "Okay, how do I do this workshop?"

[9:22](https://www.youtube.com/watch?v=9arM9b7JgOo&t=562s) So I can be like, okay, get the status.

[9:31](https://www.youtube.com/watch?v=9arM9b7JgOo&t=571s) Add on to the latest PR now. And, um, what I like about this is it has that sort of vertical tab type of thing, 'cause when you go horizontal, it's really easy to lose track of your tabs.

[9:43](https://www.youtube.com/watch?v=9arM9b7JgOo&t=583s) Um, but we've got notifications too. So when this thing is finished or this is finished and I need to look, it'll give me a notification, and I can just focus on clearing the notifications.

[9:54](https://www.youtube.com/watch?v=9arM9b7JgOo&t=594s) So here, um, the way I'm using these terminals, usually it's more like a manager rather than a coder. Um, and it's kind of interesting, but it gives you a certain benefit where I feel, I feel like the worker's not biased anymore.

[10:08](https://www.youtube.com/watch?v=9arM9b7JgOo&t=608s) So when I ha- when I code with these directly, um, I usually feel like there's a bias where it wants to say things are really working or whatever, right?

[10:16](https://www.youtube.com/watch?v=9arM9b7JgOo&t=616s) Versus, like, you know... Um, and I'll show this. One sec.

[10:24](https://www.youtube.com/watch?v=9arM9b7JgOo&t=624s) If this had been working in PR 294 by itself, I think it would've been like, "This PR is amazing," like, "We gotta merge it," right? But then this one was like, no, like, there's another PR that should supersede it, and probably we should just close this PR, right?

[10:37](https://www.youtube.com/watch?v=9arM9b7JgOo&t=637s) So that's kind of the benefit you get, where the manager has a different context, um, than the workers.

[10:45](https://www.youtube.com/watch?v=9arM9b7JgOo&t=645s) Uh, let's see. All right, so this is compacting whatever. So it'll take some time to complete. Don't wanna wait for it, but when it completes, you see these notifications, and I think my efficiency has improved a lot with cmux.

[10:59](https://www.youtube.com/watch?v=9arM9b7JgOo&t=659s) Um, I think... Is Austin or someone from cmux here?

[11:05](https://www.youtube.com/watch?v=9arM9b7JgOo&t=665s) Yeah, I'm here. What's up?

[11:06](https://www.youtube.com/watch?v=9arM9b7JgOo&t=666s) Cool. Yeah, so Austin is, uh, [clears throat] one of the guys behind cmux. Um, you know, big fan of it and I'm not, I'm not paid to say this or anything, but- [laughs] ...

[11:17](https://www.youtube.com/watch?v=9arM9b7JgOo&t=677s) big fan of cmux. Uh, I've been using it a lot. I know you can spend a minute if you wanna talk about anything cool about cmux.

[11:24](https://www.youtube.com/watch?v=9arM9b7JgOo&t=684s) Yeah. So yeah, one of the creators of cmux. Uh, really happy to have Jeff as one of our power users, um, and also, like, kind of endorsing it for free.

[11:32](https://www.youtube.com/watch?v=9arM9b7JgOo&t=692s) Um- [laughs] ... but yeah, lots of, uh, yeah, lots of things that we're shipping. We shipped a Claude Code Teams integration, so if anyone is using Claude Code Teams and wants to actually see what the sub-agents are doing, we'll automatically spawn terminals for that.

[11:46](https://www.youtube.com/watch?v=9arM9b7JgOo&t=706s) Uh, we also shipped, uh, cmux SSH. So if you do any SSH work, um, you can use our native cmux SSH to, you know, do your Tailscale, et cetera, um, to other computers.

[11:57](https://www.youtube.com/watch?v=9arM9b7JgOo&t=717s) You can even use it to run your own OpenClaw, um, in your Mac Minis. Um, but yeah, just, uh, one of the creators-

[12:05](https://www.youtube.com/watch?v=9arM9b7JgOo&t=725s) Please feel free to email me if you have anything that you think is a bug or any feedback, feature requests. Um, I'm always available, and yeah, I just love seeing people using cmux and always wanna take as much feedback as I can to, like, get them as, get them-

[12:27](https://www.youtube.com/watch?v=9arM9b7JgOo&t=747s) Okay, so just download that.

[12:34](https://www.youtube.com/watch?v=9arM9b7JgOo&t=754s) Yeah. They actually have an app too, so the app might be nice.

[12:37](https://www.youtube.com/watch?v=9arM9b7JgOo&t=757s) Yeah. Okay. And then use that to help me get back in and set-

[12:43](https://www.youtube.com/watch?v=9arM9b7JgOo&t=763s) Yeah

[12:43](https://www.youtube.com/watch?v=9arM9b7JgOo&t=763s) ... set up.

[12:44](https://www.youtube.com/watch?v=9arM9b7JgOo&t=764s) Yeah.

[12:45](https://www.youtube.com/watch?v=9arM9b7JgOo&t=765s) Okay. Okay, cool. Thanks.

[12:47](https://www.youtube.com/watch?v=9arM9b7JgOo&t=767s) All right. Does using the sandbox... It should not. Where would you, um... Have you had, have you run into any troubles, Aaron, about sandbox token usage?

[12:57](https://www.youtube.com/watch?v=9arM9b7JgOo&t=777s) Uh, no. I'm just, I'm not technical at all.

[13:01](https://www.youtube.com/watch?v=9arM9b7JgOo&t=781s) Oh, yeah, yeah.

[13:01](https://www.youtube.com/watch?v=9arM9b7JgOo&t=781s) I have an OpenClaw installed, so I'm just-

[13:03](https://www.youtube.com/watch?v=9arM9b7JgOo&t=783s) Okay

[13:04](https://www.youtube.com/watch?v=9arM9b7JgOo&t=784s) ... very newbie questions. [laughs]

[13:06](https://www.youtube.com/watch?v=9arM9b7JgOo&t=786s) No, no.

[13:06](https://www.youtube.com/watch?v=9arM9b7JgOo&t=786s) But I appreciate you-

[13:07](https://www.youtube.com/watch?v=9arM9b7JgOo&t=787s) No, no bad questions

[13:08](https://www.youtube.com/watch?v=9arM9b7JgOo&t=788s) ... pretty much, anyway.

[13:08](https://www.youtube.com/watch?v=9arM9b7JgOo&t=788s) It's all good. Um, yeah. Uh, no, the sandbox wouldn't do that. Um, I think if, if everything's working well for you, you know, keep using the sandbox. For me, I just, you know, don't use the sandbox and so, so far nothing bad has happened.

[13:21](https://www.youtube.com/watch?v=9arM9b7JgOo&t=801s) But I think if I had-

[13:22](https://www.youtube.com/watch?v=9arM9b7JgOo&t=802s) Yeah

[13:22](https://www.youtube.com/watch?v=9arM9b7JgOo&t=802s) ... an external bot, then I would use the sandbox too.

[13:27](https://www.youtube.com/watch?v=9arM9b7JgOo&t=807s) You changing the mo- testing a new model, like it'll go down, then I have to figure out how to get it back up again. So I think I want to set up the sandbox because-

[13:35](https://www.youtube.com/watch?v=9arM9b7JgOo&t=815s) Oh, sorry, sorry. Um, okay, wait. There's two kinds of things. Okay.

[13:39](https://www.youtube.com/watch?v=9arM9b7JgOo&t=819s) The sandbox that most people talk about means, like, they run it in Docker or they, like, have it running in-

[13:45](https://www.youtube.com/watch?v=9arM9b7JgOo&t=825s) Oh

[13:45](https://www.youtube.com/watch?v=9arM9b7JgOo&t=825s) ... an isolated part of their system.

[13:46](https://www.youtube.com/watch?v=9arM9b7JgOo&t=826s) Mm-hmm.

[13:47](https://www.youtube.com/watch?v=9arM9b7JgOo&t=827s) But the other one was the one where I made the staging instructions, where I was like, "Oh."

[13:51](https://www.youtube.com/watch?v=9arM9b7JgOo&t=831s) Yeah.

[13:51](https://www.youtube.com/watch?v=9arM9b7JgOo&t=831s) Okay. So-

[13:52](https://www.youtube.com/watch?v=9arM9b7JgOo&t=832s) That's what I'm looking for

[13:53](https://www.youtube.com/watch?v=9arM9b7JgOo&t=833s) ... that, that could double your token usage if you send the same work to both of them. If you have two-

[13:58](https://www.youtube.com/watch?v=9arM9b7JgOo&t=838s) Got it

[13:58](https://www.youtube.com/watch?v=9arM9b7JgOo&t=838s) ... right. Um, but I think the way I would use it is not like that. Like, I think I would do local development, and then I would run integration tests on the, um, sandbox or staging one, right?

[14:09](https://www.youtube.com/watch?v=9arM9b7JgOo&t=849s) So I have two of them, and then once, like, everything's good, then I would merge the code and deploy to the production one. Um-

[14:16](https://www.youtube.com/watch?v=9arM9b7JgOo&t=856s) I see

[14:16](https://www.youtube.com/watch?v=9arM9b7JgOo&t=856s) ... so it wouldn't double your usage, but it would definitely increase it, but then the benefit is you might have some more reliability. So-

[14:22](https://www.youtube.com/watch?v=9arM9b7JgOo&t=862s) Yeah. Got it

[14:23](https://www.youtube.com/watch?v=9arM9b7JgOo&t=863s) ... I, I made some instructions and I was kind of in the middle of setting it up, but then, you know, it's like competing with the other one, so I gotta debug it.

[14:30](https://www.youtube.com/watch?v=9arM9b7JgOo&t=870s) Yeah.

[14:30](https://www.youtube.com/watch?v=9arM9b7JgOo&t=870s) But I think, you know, it's, it's worth trying out though, so I add that for more advanced people to give it a, uh, give it a try.

[14:37](https://www.youtube.com/watch?v=9arM9b7JgOo&t=877s) Cool. Thanks. Well-

[14:38](https://www.youtube.com/watch?v=9arM9b7JgOo&t=878s) Or even if you're not as advanced, if you want it, you know, you can try. [laughs]

[14:41](https://www.youtube.com/watch?v=9arM9b7JgOo&t=881s) Yeah, I'm definitely gonna play around. But what, uh, what model do you use? Like, do you have a, something that, like a default orchestrator model and then you, like-

[14:51](https://www.youtube.com/watch?v=9arM9b7JgOo&t=891s) Yeah, so-

[14:51](https://www.youtube.com/watch?v=9arM9b7JgOo&t=891s) ... say for this, use that

[14:52](https://www.youtube.com/watch?v=9arM9b7JgOo&t=892s) ... I mostly use Codex 5.3. Um, I found, I found, uh, GPT-5.4 to just use more tokens. Um, and even 5.3, like, like I, I just get destroyed all the time, right?

[15:06](https://www.youtube.com/watch?v=9arM9b7JgOo&t=906s) So I might have to adjust that.

[15:08](https://www.youtube.com/watch?v=9arM9b7JgOo&t=908s) Yeah.

[15:08](https://www.youtube.com/watch?v=9arM9b7JgOo&t=908s) Um, so basically I use this until, like, this is getting low, and then I just switch to MiniMax, which is not as good, but it kind of gets the job done.

[15:17](https://www.youtube.com/watch?v=9arM9b7JgOo&t=917s) Yeah.

[15:17](https://www.youtube.com/watch?v=9arM9b7JgOo&t=917s) And then this is more about money than, like, preference, but

[15:22](https://www.youtube.com/watch?v=9arM9b7JgOo&t=922s) some, some work I can still kind of just do, um, here, so I don't always have to-
