ninja nerdingDavid Ondrej's mini software factory

David Ondrej's mini software factory

David Ondrej has spent 2,000+ hours coding with AI and interviews the people building it. In this 61-minute whiteboard talk he says the next step isn't better prompting. It's getting yourself out of the way: things start the agents, each agent checks its work and closes quietly, and many of these loops make a factory. Then he shows the 32 loops he runs.

Jump to the loop map, his loops, or build your first one.

Original sources

David Ondrej · Agentic Engineering in 2027 (61 min) youtu.be davidondrej/skills on GitHub github.com Cloudroom, his app cloudroom.dev

The video

61 minutes, posted Oct 11, 2026, on his channel. YouTube also shows it as “Stop coding, build Software Factories instead”. It has no chapters, so these are ours. Every timestamp on this page opens the video at that moment.

0:00 What's coming, and who he is
0:35 Astra, Opus 5.5, and "we're all getting replaced"
1:19 What people still do better than agents
3:05 Look at the past: farming and human computers
4:32 Sponsor read: PostHog (until 5:50)
5:50 The staircase: from doing the task to running the factory
6:26 Triggers, not prompts. The higher-level work
10:45 Agentic loops: remove yourself, a small slice at a time
13:12 Track where your time goes
14:47 The big mistake: you are the bottleneck
17:18 Every loop has two halves: trigger and execution
18:38 The laptop problem
21:18 One agent starts 110
22:27 immortal-agents: restart what died
23:06 Local agents vs cloud agents
26:41 His automations, one by one
30:05 Why cloud agents are hard, then Cloudroom (until 36:15)
36:16 Your subscription has more tokens than you use
38:23 Steal his loops. The test gap hunt
40:35 Inference: which subscription, which model
43:09 Review with the other lab
45:12 What starts an agent
46:56 Prompts, skills, and next: sequences
49:56 Loop vs factory
51:04 Live: building a product-gap loop by voice
54:41 Agents managing agents. Local vs cloud speed
56:29 The gap keeps growing
57:47 How to see the future: thinking sessions
60:16 Outro: Cloudroom Ultra

Twelve signals

The whole talk in twelve boxes. Each links to the part of this page that explains it.

016:26
Stop starting agents one by one
Typing a prompt and waiting was fine through most of 2026. His claim: it's now the slow way, because you can only unblock about five agents at a time.
How
0245:12
Something else presses start
A schedule, a webhook, an outage, a customer report or another agent. Not you typing, not even you talking.
How
0349:56
A loop is trigger, work, check, repeat
An agent does one kind of job, its work gets checked, and it runs again next time. People can still approve the result.
How
0450:52
A factory is many loops
Billing, database, security, cleanup, tests, feedback: one loop each, side by side. He calls his a mini factory because it isn't finished.
How
0513:04
Start with the predictable slice
Most of what you do each week is the same type of task. Hand over the safest 5% first, then the next 5%.
How
0617:18
Two halves: trigger and execution
What starts the job, and what the agent gets to do it: model, skills, context, tools. Getting both right is the craft.
How
0728:33
Most runs should end quietly
If nothing is wrong, the agent writes two lines and archives itself. Only real findings wait for you.
How
0843:54
Check with a second lab's model
Built with Opus? Review with GPT. Built with GPT? Review with Opus. Different training catches different mistakes.
How
0918:38
Agents need a computer that never sleeps
Close the laptop and local agents stop. Triggers need a machine that's always on, and each agent is safer in its own sandbox.
How
1049:05
Skills today, sequences next
A prompt you repeat becomes a snippet, then a skill. His guess for the next six months: chains of skills learned from how you work.
How
119:05
Your job moves up a level
Create agents, run fleets, split the budget, pick models and harnesses, measure results, and think.
How
1257:47
Thinking is the hard part now
He blocks 60 to 90 minutes, no screens, to reason about what's coming. Clicking around is what agents do.
How

Words on this page

25 terms, in plain words. Skip this if you already run agents every day.

Agent: An AI model that can take steps on its own: read files, run commands, search, write code, then look at the result and keep going.
Harness: The program wrapped around a model that runs those steps. Claude Code, Codex, Cursor, Pi, Hermes and OpenCode are harnesses.
Token: The unit models count and charge in. Every request and every answer uses tokens.
Subscription vs API pricing: A subscription is a flat monthly plan with usage limits. API pricing charges for every token. Ondrej says flat plans give far more for the money right now.
Trigger: Whatever starts an agent. A schedule, a webhook, an alert, a customer message, or another agent.
Webhook: A message one system sends another the moment something happens. "A payment just failed" can arrive as a webhook and start an agent.
Schedule (cron): A timer: every 10 minutes, every 4 hours, once a day. Cron is the old Unix name for it.
Unit of work: One job, sized so an agent can finish it in one go. "Check the billing code for new bugs" is one. "Run the company" is not.
Execution: The second half of a loop: which model does the work, and which skills, context and tools it gets.
Agentic loop: Trigger, the agent works, the work is checked, and it repeats next time. It may still end with a person approving.
Software factory: Many loops running side by side toward one outcome, mostly without a person. Ondrej calls his a mini software factory.
Local agent: An agent running on your own laptop or desktop. It stops when the machine sleeps, loses Wi-Fi or runs out of battery.
Cloud agent: An agent running on a server that is always on. You pay while it runs and can start as many as you need.
Sandbox: A sealed-off computer, usually a small virtual one, where one agent works. If it goes wrong, only that sandbox is affected.
Worktree: A second working copy of the same code project, so two agents can edit without stepping on each other. Ondrej says it only goes so far on one laptop.
Computer use: An agent that moves the mouse and types on a screen like a person. Handy for clunky websites, annoying when it's your screen.
Subagent: An agent started by another agent to do part of the job. The first one acts as the manager.
Prompt template / snippet: A message you type often, saved so one shortcut pastes it. He keeps his in Raycast.
Skill: A saved, written-out procedure an agent loads when the task calls for it, often started with a slash command. Like an SOP for agents.
Sequence: Ondrej's prediction, not a real feature yet: a chain of skills that usually run back to back, learned from your own agent history.
Adversarial review: Asking a second agent to argue against the first one's work: why this is wrong, unneeded or unsafe.
Self-archive: When an agent finds nothing worth your time, it closes its own thread so it never lands in your queue.
ADR: Architecture decision record. A short file saying what a team decided and why. His product-gap loop checks ideas against them.
Evals: Tests for agents: how often they succeed, how many tokens they burn, what share of tasks they handle.
MCP: Model Context Protocol. A standard way to plug a tool or app into an agent.

Four steps up: from doing the task to running the factory

His drawing is a staircase. Each step up, the work gets less manual and more abstract. Most people, he says, are on step one or two. 5:50

01
Do the task
You sit at the computer and do the work yourself.
You do everything
02
Run agents
You prompt Claude Code, Codex or Cursor, wait, read, prompt again. Where he says most people are stuck.
You start and unblock each one
03
Design loops
You set up an agent that starts on its own for one kind of job, with rules for when to bother you.
You design the loop and approve what it finds
04
Run the factory
Many loops run side by side. You decide what they're for, what they cost and whether they're working.
You allocate, measure and think

The big mistake, in his words, is assuming we'll keep working with agents the way we do now. Today you start agents one by one and unblock them one by one. Soon triggers start them and they run 24/7 in the cloud. 14:47

Your job once agents do the work 9:05

Create new agentsSet up agents for one job, or general ones.
Manage fleetsA marketing team of agents, a product team, a support team.
Allocate resourcesOf $50k a month, how much goes on tokens, salaries, ads and hardware.
Choose models and harnessesA cheap fast model for easy jobs, the best one for the important ones.
Establish evalsWhich share of tasks agents do, how many tokens they burn, whether they're good.
Spend more time thinkingHow to grow, what you're not doing yet, which loop to add next.

What people still do better

1:19

Creativity and new ideas: you've taken in sound, touch and sights that were never written down, so they aren't in any model's training data.
Being practical: a model doesn't know you only have an hour, so it won't skip details or hold back on tests.
Taste: anyone can make a thousand apps or images. Knowing which one is good is still a person's job.

So stop holding on to what models do better. His comparison: insisting on writing code line by line is like being an elevator operator after elevators went automatic.

Loops anyone can run · three basic

Starts: Every Friday at 5 pm

Where did my week go?

An agent reads your calendar and sorts the week into a few broad buckets. He does this with the Composio CLI on 14 days of 15-minute calendar entries.

Quiet when: Always reports. It's a summary.

Starts: Every 2 hours

Inbox triage

Reads new email, drafts replies to the routine ones, flags the three that need you.

Quiet when: Nothing new: archives itself.

Starts: Every morning

Competitor watch

Checks three competitor sites and changelogs for pricing or feature changes.

Quiet when: No change: two lines, then closes.

Loops for a running product · three advanced

Starts: A new row in the feedback table

Customer bug reports

An agent investigates each report. Edge cases and off-target ideas close themselves. Real bugs come to you in plain English with the fix. (His.)

Quiet when: Small or no issue: self-archives.

Starts: Every 30 to 90 minutes

Security sweep

Pen-tests your own code for leaks, admin access and other holes before someone else does. (His.)

Quiet when: Nothing found: self-archives.

Starts: A webhook from your payment provider

Payment failures

When payments start failing, an agent checks the billing code and logs and explains what broke. His example of a webhook trigger.

Quiet when: One-off failure: logs it and closes.

Cards marked “His” are loops he runs. The rest are FakeNerd's examples of the same pattern. The calendar audit is his, run by hand in the video.

Everything he names

The ideas don't need any one tool. He uses Claude Code with Opus for almost everything, GPT for review, and Cloudroom, which he builds, to run it all. Model names are as of October 2026 and change fast.

Harnesses · the agent programs

Main harnessAnthropic
Claude Code
Runs about 98% of his threads, with Opus 5.5. He pays for two $200 plans.
42:41 Site
ReviewerOpenAI
Codex
He used to pay for six $200 Codex plans. Now he uses GPT models mainly to review Opus's work.
43:09 Site
Open harnessesOpen source
Pi, Hermes, OpenClaw
His point: harnesses got much better in a year because the open ones copy each other's best ideas.
12:17 Site
Budget optionOpenCode
OpenCode Go
His pick if you can't afford a $200 plan: "insane value". $10 a month for open models.
15:21 Site

Models · the brains he picks between

BuilderAnthropic
Opus 5.5
His default for almost everything, on Extra High or Max effort. He calls it AGI-level, fast and token-efficient.
36:41
ReviewerOpenAI
GPT-6.1 Sol
Used as the second-lab reviewer, in Codex, at Extra High or Max.
43:54
Was the bestOpenAI
Astra
Best in the world for about three weeks, he says, until Opus 5.5. Still used for reviews of big changes.
41:11
Managers and workersAnthropic
Sonnet 5.5, Haiku
In his 110-agent demo, Sonnets manage and Haikus do the small jobs. Haiku is his pick when you must pay API prices.
21:37
Cheap and fastDeepSeek
DeepSeek V4.1 Flash
His example of the model to use for an easy task where cost matters more than brains.
9:49

Where agents run · cloud agent tools

His own productOndrej's team
Cloudroom
Desktop app for local and cloud threads, built on bb, with scheduled automations. Bring your own subscriptions. Cloud threads run Claude Code, Codex and Pi. Core is open source. Every demo in the video runs in it. Ultra, the only paid plan open, is $500 a month.
31:28 Site
Other cloud agentsSeveral
Cursor, Devin, Amp, Claude
The cloud agents from big companies. His complaints: closed source, and some make you use their own harness and plan.
30:10

His kit · repos, tools and sources

RestarterVectal Labs
immortal-agents
Revives agents after an internet outage of 2+ minutes by sending "keep going". macOS only. His first try at the laptop problem.
22:27 Site
Agent that manages agentsVectal Labs
Director
Watches your agents in bb or cmux, reviews the ones that stopped and drafts the next message, learning your style from your corrections. It asks before sending anything.
46:03 Site
His skillsOndrej · MIT
davidondrej/skills
His public skills repo, about 4.1k stars on screen. Folders for agent orchestration, skill writing, research, thinking and docs, and setup.
47:57 Site
App connectorComposio
Composio CLI
Lets his agent read his calendar for the time audit, through a skill he wrote for it.
13:26 Site
Prompt shortcutsRaycast
Raycast snippets
Where he keeps the prompts he types every day, so a few keys paste them.
47:40 Site

Also named, not part of the setup

SemiAnalysis Research firm whose chart he shows on what each $20, $100 and $200 plan is worth at API prices.41:50
Artificial Analysis Where he says to compare model prices if you have to pay per token.45:03
n8n Automation tool he recommended years ago. The same advice holds: automate a small task, not a big one.11:30
SupabaseThe database his bug-report loop watches for new rows.28:02
PostHog The sponsor. Product analytics and session replay. Not part of his loops.4:32

The loop map

Seven steps that repeat, plus three things around them. Darker boxes need you: two of seven, and he wants fewer. Click any box to read it, or press Start and follow one bug report.

One loop · darker boxes need you

Around the loop

Follow one bug report through the loop

Six beats, using the loop Ondrej calls especially good: a customer reports a bug inside his app. Watch which boxes light up, and how often the answer is to close quietly.

The loop · step 1 of 7 · Machine

Watch at 45:12

Something starts it

schedule
webhook
incident
feedback
another agent
Triggers

The loop wakes up without you. On his board: billing every 4 hours, the database every 5, security every 30 to 90 minutes, customer feedback every 10.

Why: Every prompt you type costs your attention. Voice is faster than typing but still costs it. A trigger costs nothing.

What you see

A new thread appears in the sidebar by itself. He points one out live at 16:01.

Watch out

Too often and it burns tokens on nothing. Too rarely and problems wait. He tunes the timing per loop.

His own short version, from the whiteboard: loop = trigger → agent works → check → repeat. A factory is many loops chained. The seven steps above spread that out using what he shows on screen, and the order is ours. 49:56

What starts it, and what it gets

Every loop has a trigger and an execution. The trigger replaces you pressing enter. The execution is everything the agent is handed to do the job well. 17:18

Half one · what starts an agent 45:12

A scheduleEvery 10 minutes, every 4 hours, once a day
A webhookA payment failed. A form was sent.
An incidentDatabase at 90% of its connections. An error spike.
Customer feedbackA new bug report or feature request
A proactive huntLook for bugs, holes or missing tests in one area
Another agentA manager starts workers, or reviews and unblocks them

one unit of work

Half two · what the agent gets 17:54

ModelBest one for important work, a cheap one for easy work.
SkillsThe written procedure for this exact job.
ContextWhich files, docs and decisions it reads first.
ToolsMCPs and APIs it can call: database, GitHub, calendar.

“That is the art,” he says. A powerful model is the easy part. Which skills, context and tools it gets is where loops succeed or make slop.

“Another agent” is the trigger he calls the hardest frontier. A manager agent that has learned your rules can unblock workers faster than you can. His open-source Director is an early try: it watches agents in bb or cmux and drafts your next message, but still asks before sending. 46:03

His loops: one per department

31 automations on his Cloudroom board, 32 after the live demo. Ten are named in the video. His tip for finding yours: picture your company 10x bigger, list the teams it would have, and give each one a loop. 27:43

Every 4 hourssaid and on screen
Billing review
Checks all the billing code for new bugs or anything missed last time.
26:56
Every 5 hourssaid and on screen
DB health check
Looks for database trouble: too many connections, CPU or memory running out when power users pile in.
27:02
Every 10 minsaid and on screen
Feedback threads
Picks up new customer reports from a database table and starts an Opus investigation for each.
27:56
Every 2 hourssaid and on screen
GitHub issues + PRs
Reviews outside issues and pull requests on his public repos with his larp-detector skill: is this a real problem, or someone's agent padding the contributor list?
38:30
Every 10 minsaid and on screen
Sandbox alerts
Watches the cloud sandboxes for problems and hitting limits.
38:36
Every 30–90 minsaid and on screen
Security sweep
Pen-tests his own code: data leaks, admin access, ways to knock it over. Titled "every 90 min", scheduled every 30.
29:33
Every 3 hourssaid and on screen
Simplify sweep
Looks for needless complexity and unused code, one section at a time. Investigate only.
38:42
Every 5.5 hourssaid and on screen
Test gap hunt
Looks for tests that are clearly missing. Opus suggests, GPT argues against it, and only if both agree does it reach him.
38:47
Every 2 hourssaid and on screen
Product gap
Built live: finds one obvious product improvement that fits his decision records, then a GPT reviewer argues against it.
51:52
Not shownon screen only
Tweet scout
Appears only as threads in his sidebar ("Tweet scout: top 3…"). Not explained in the video.
27:00

The cheap gate · read from screen

39:00

A script decides before a model wakes up

His test gap hunt is a short bash script that runs every 30 minutes. It only starts a hunt if the last one began 5h25m ago, picks the area hunted least recently, skips areas with a hunt already open, and prints nothing when it starts nothing. Most runs in its log say “empty output”.

Most runs find nothing

28:56

That's the point

The database check usually finds no problem. Opus on max effort looks, finds nothing, and closes itself. He calls that “tremendous value”: the one time there is a problem, it's caught and explained in plain English with the fix.

Two labels on his board don't match their timers: “Security sweep (every 90 min)” is set to every 30 minutes, and the test gap hunt's 30-minute timer is the gate described above. We give both.

The prompts

Two of his loop prompts, each with a fill-in version, plus two FakeNerd starters. The sweep prompt is read off the screen. The product-gap prompt is what he said aloud, also shown on screen. Both name his tools; the fill-ins don't.

1 · One section, investigate only, close quietly 43:30

His · simplify sweep (from screen)

Simplify sweep, section 16: Other plugins.
Follow .agents/skills/simplify-sweep/SKILL.md for this section only.
Investigate only: do not edit code.
If nothing is clearly worth doing, write 2-3 lines on what you covered, then archive this thread with the self-archive skill (room-cli thread archive --self --json).
Otherwise tell David in plain English, in a few sentences per finding, what you found and the obvious, safe fix. Then wait for him.

Fill-in version

[Job name], [part 3 of 12]: [which area].
Follow [path to the skill for this job] for this part only.
Investigate only: do not change anything.
If nothing is clearly worth doing, write 2-3 lines on what you covered, then close this thread.
Otherwise tell [your name] in plain English, in a few sentences per finding, what you found and the obvious, safe fix. Then wait for [your name].

On screen this run worked for 4 min 12 s and came back with one finding: 23,944 lines of unused copies, safe to delete, “No code changed. Waiting for your approval.” The self-archive command is his self-archive skill.

2 · A new loop, built by voice in under a minute 51:52

His · product-gap automation (spoken)

Create a new Cloudroom automation where every two hours, a new thread spawns with Opus 5.5 extra high as the model, and it looks for product gaps against all of the ADRs we have in /docs/ADR and looks for one obvious improvement for our product. It could be a feature, it could be more clear UI, anything. It just needs to be aligned with our ADRs and decisions we've made in the /docs folder.

Then when it finishes and it has a good idea, launch a reviewer, a subagent below it, with GPT 6.1 fast extra high as the model, doing adversarial review to try to make the arguments of why this shouldn't be a feature and why this shouldn't be added.

Once the subagent finishes, it should go back to the main agent, and it should review the feedback of the subagent, thinking about it from first principles. If it agrees with the subagent, it should simply archive both threads. But if it disagrees, it should keep this thread open, waiting for me, David, to review it.

Create this Cloudroom automation now. Keep it simple. Don't overthink it.

Fill-in version

Create a scheduled job that runs every [2 hours]. Each run starts a fresh agent with [your strongest model] that reads [the file or folder where your decisions live] and looks for one obvious improvement to [your product / your offer / your website]. It must fit the decisions in that folder.

When it has a good idea, start a second agent with [a model from a different company] to argue against it: why this shouldn't be done.

The first agent then reads that argument and thinks it through. If it agrees with the reviewer, close both. If it disagrees, keep the thread open for [your name] to review.

Keep it simple.

He speaks this to an agent inside Cloudroom, which writes the automation for him. A new loop, he warns, usually needs a few tweaks in its first runs before it stops wasting tokens.

3 · FakeNerd starters, built from his rules

FakeNerd starter · your first loop

You run on a schedule. Nobody is watching you start.

Job: [one predictable job, e.g. "check yesterday's new support emails for anything urgent"].
Read first: [the files, docs or folder you need].
Rules:
- Investigate only. Change nothing.
- If nothing is clearly worth my time, write 2-3 lines on what you checked and stop. Do not message me.
- If something is, tell me in plain English, a few sentences per finding: what you found, why it matters, and the obvious safe next step. Then wait.
- Never invent findings to look useful. "Nothing today" is a good answer.

FakeNerd starter · second-lab reviewer

Another agent made this finding: [paste or link it].

Act as a sceptical reviewer from a different team. Argue against it:
- Is it real, or a misreading?
- Is it worth doing now, or is it noise?
- Is the suggested fix safe? What could it break?

End with one line: KEEP or DROP, and the single strongest reason.

Simplify sweep, section 16: Other plugins.
Follow .agents/skills/simplify-sweep/SKILL.md for this section only.
Investigate only: do not edit code.
If nothing is clearly worth doing, write 2-3 lines on what you covered, then archive this thread with the self-archive skill (room-cli thread archive --self --json).
Otherwise tell David in plain English, in a few sentences per finding, what you found and the obvious, safe fix. Then wait for him.

Create a new Cloudroom automation where every two hours, a new thread spawns with Opus 5.5 extra high as the model, and it looks for product gaps against all of the ADRs we have in /docs/ADR and looks for one obvious improvement for our product. It could be a feature, it could be more clear UI, anything. It just needs to be aligned with our ADRs and decisions we've made in the /docs folder.

Then when it finishes and it has a good idea, launch a reviewer, a subagent below it, with GPT 6.1 fast extra high as the model, doing adversarial review to try to make the arguments of why this shouldn't be a feature and why this shouldn't be added.

Once the subagent finishes, it should go back to the main agent, and it should review the feedback of the subagent, thinking about it from first principles. If it agrees with the subagent, it should simply archive both threads. But if it disagrees, it should keep this thread open, waiting for me, David, to review it.

Create this Cloudroom automation now. Keep it simple. Don't overthink it.

You run on a schedule. Nobody is watching you start.

Job: [one predictable job, e.g. "check yesterday's new support emails for anything urgent"].
Read first: [the files, docs or folder you need].
Rules:
- Investigate only. Change nothing.
- If nothing is clearly worth my time, write 2-3 lines on what you checked and stop. Do not message me.
- If something is, tell me in plain English, a few sentences per finding: what you found, why it matters, and the obvious safe next step. Then wait.
- Never invent findings to look useful. "Nothing today" is a good answer.

Build with one lab, review with the other

Right now he counts two frontier labs: OpenAI and Anthropic. Whatever one builds, the other reviews. 43:54

BuildLab A finds or makes itOpus 5.5 does about 98% of his threads.
ReviewLab B checks itGPT-6.1 Sol or Astra. Two reviewers if it's serious.
WeighBack to the builder"Is this legit, or just overthinking?"
DecideBoth agree, or you decideAgree it's bad: archive. Disagree: wait for you.

Neutral review

43:40

Tell it what, not what to find

His gpt-review skill gives the reviewer scope, files and intent, and asks for a senior review without hinting at suspected bugs. Review only, no edits, plain English.

Adversarial review

39:14

Tell it to argue against

In the test gap loop the GPT reviewer assumes the test is pointless. Only if both models agree the test is worth adding does it reach him. Agents love writing tests; this stops the flood.

Prompts to skills to sequences

Skills are the first step to removing yourself, he says, but you still have to call them. His guess for what comes next is the last rung. 46:56

01You type it every time
Notice
Spot the message you type again and again.
"Answer in short plain English."
02You press a shortcut
Snippet
Save it as a prompt template so a shortcut pastes it.
His Raycast snippets
03You type a slash command
Skill
Write the whole procedure down as a skill the agent loads on one command. An SOP for agents.
/opus-review, release skills, computer-use skills
04Prediction, not a product yet
Sequence
His prediction: skills that usually run back to back, chained by watching your agent history.
"In this situation David runs these three skills, 98% of the time."

His daily snippets · said aloud, caption-cleaned 47:21

Is it still broken?

Rebase off of main, check the underlying code to see if it's been fixed or not yet. Answer in short plain English.

Make it short

Don't be verbose. Make your answer simple and short, focused on what really matters.

Research wide

Run 4x varied search, 3x deep research, and 3x deep scrape on this.

Anything left?

Anything else to do here or not? Remind me of the original purpose of this.

“Varied search”, “deep research” and “deep scrape” are skills in his repo, powered by DeepAPI, his earlier product. Use your own research tool in their place.

Skills from his public repo that fit this page

self-archive Writes a short closing note, then archives the thread and stops it. The quiet-close step of every loop.
gpt-review Starts a GPT reviewer through Codex with a neutral brief: scope, files, intent. Review only, no edits, plain-English report.
total-review Runs two reviewers from different labs, then merges what they found for your approval.
larp-detector Sceptical review of outside pull requests: did this come from a real bug, or an agent hunting for something to contribute?
decisions Lists the choices the agent made and isn't sure about. The decision skill he mentions.
goal-loop Keeps an agent working toward one goal over many rounds. Not shown in the video.

The repo is a cleaned-up public copy of his own (MIT, about 4.1k stars). The release skills and the Composio skill he mentions aren't in it.

Local agents vs cloud agents

His “laptop problem”: running 20 agents on one laptop is like 20 new hires sharing one computer. And a trigger at 3 am needs a machine that's awake. 18:38

Where it runs

Local: Your laptop or desktop

Cloud: A server, one sandbox per agent

When it stops

Local: Lid closed, Wi-Fi lost, battery dead

Cloud: When you stop it

How many at once

Local: Until the fans scream. Worktrees help a bit

Cloud: As many as you pay for, up and down

Computer use

Local: Takes over the screen you're using

Cloud: Clicks around on its own screen

If one is hacked

Local: Your whole machine, logins and data

Cloud: Just that sandbox

Starting triggers

Local: Only while the machine is awake

Cloud: Any time, 24/7

Good for

Local: Private files, tidying your own folders

Cloud: He says 90 to 95% of agent work

The trend