The argument in one line.
Running a startup in 2026 means becoming a full-time manager of AI coding agents rather than a part-time coder, and the people who master that management skill — working from the cloud, making dozens of high-stakes decisions a day, and routing tasks to the right-priced model — will out-ship everyone still working locally.
Read if. Skip if.
- A solo founder or one-person startup team trying to scale output without hiring, especially anyone already running Claude Code, Codex, Devin, or Cursor day to day.
- A technical or semi-technical builder who has tried an AI coding agent once or twice but hasn't built a repeatable system around running several at once.
- Anyone managing a real product with paying customers who needs a way to catch production bugs and regressions without manually reading logs every day.
- A founder or solopreneur worried about a ballooning AI token bill who wants a concrete monthly budget and a model-routing strategy.
- You want a tutorial on writing your first prompt or picking your first AI coding tool — this assumes you already have an agent workflow running.
- You're looking for enterprise engineering-org advice — Ryan's playbook is built for a team of one to a handful of people, not a scaled engineering department.
The full version, fast.
Ryan Carson, a solo founder running the AI divorce-tech startup Untangle, argues the highest-leverage skill for 2026 is managing teams of AI coding agents rather than writing code yourself. He works entirely from cloud-based virtual machines (mainly Devin) so five to ten agents run in parallel without code collisions, shipping 22 to 40 pull requests a day, and does roughly half of that management from his phone. The job has shifted from typing code to making 10 to 20 high-stakes decisions before lunch, which he survives by pinning his most important threads and checking in on a roughly 25-minute cadence. He layers in automations — an end-to-end signup test, a daily production-watchdog summary of customer activity, and a self-improvement loop that grades and fixes an AI agent's own customer conversations — so the system keeps improving without his constant attention. After a $20,000 token month, he settled on budgeting about $5,000 per 'engineering employee' a month by routing cheap, high-volume work to a fine-tuned model and reserving frontier models for genuinely hard calls, and warns against building an entire software factory on one frontier lab's own coding tool.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Who's talking.
Where the time goes.

01 · Intro
Greg's cold open frames the episode's thesis — people who run teams of AI agents will outperform everyone else — and brings on Ryan Carson to explain cloud agents, automations, and building a software factory.

02 · The New Agent Paradigm
Ryan lays out his background: 25 years as a founder, scaled Treehouse to 110 employees and a million learners, and now runs Untangle — an AI divorce agent for family law firms — as a team of one with revenue on track to 4x this month. States that everyone, regardless of prior role, is now a manager of agents.

03 · Inside Ryan's eight-screen desk setup
Screen-share tour of his 52-inch monitor split into eight zones: Slack for agent notifications, a UG Monk paper to-do system, a vertical mouse and WhisperFlow for voice input, 1Password to keep prod keys isolated from agents, Devin, two testing screens, X, and Codex. About half his work happens on his phone.

04 · Why Devin and cloud agents
Explains why cloud-hosted agents beat local development: cloud VMs eliminate git-worktree and code-collision overhead, letting him run 5-10 agents in parallel. Calls working purely locally 'caveman' behavior that ships 10x less.

05 · Everyone Is Now a Manager of Agents
Responds to 'local maxis' on X who see cloud agents as amateurish — says they're not doing real work. Describes needing to 50x his output once Untangle hit product-market fit and started shipping real fixes to paying customers.

06 · Local vs Virtual Development
Transition into how to structure a system that doesn't drive the operator crazy once output scales — reframing the job itself around decision-making rather than typing.

07 · Agent Management System
The core operating system: work is now making 10-20 high-stakes decisions before lunch; pin the threads that matter and let the rest run; check in on a roughly 25-minute cadence. Shows his real PR chart averaging 22-25 PRs a day (up to 40), including 8 PRs shipped from his phone while hiking Mount Washington with his son.

08 · 3 Automations to build
Covers the end-to-end signup test (browser QA three times a week, ~$60 in tokens per run), the production watchdog (9am daily digest of customer activity linked to real UI), and the pattern of spinning up a manager thread that delegates to cheaper child agent sessions.

09 · Self-improvement loop with Grace
Describes Grace, the AI paralegal agent inside Untangle, and the daily loop that grades her customer chats against a rubric, auto-spins a fix session for anything scoring low, and ships roughly three small UX fixes a day.

10 · Token costs and model routing
A $20k token month was the wake-up call. Settles on roughly $5,000 per 'engineering employee' a month, using Cognition's cheaper fine-tuned SWE-1.7 for high-volume loop work and reserving frontier models for hard calls. Warns against building a company's entire software factory on a single frontier lab's own tool (Claude Code, Codex) since those labs aren't incentivized to optimize cost.

11 · Building reputation on X
Argues that publicly sharing what you're learning on X compounds into real relationships and opportunities, citing his own relationship with Greg and Sahil Bloom's rise from private-equity newsletter writer to bestselling author.

12 · Closing thoughts
Recaps the three takeaways — cloud agents, automations, and building public credibility — and Greg signs off, pointing listeners to follow Ryan on X.
Lines worth screenshotting.
- A one-person startup can ship 22 to 40 pull requests a day by running five to ten cloud agent sessions in parallel instead of coding locally.
- Cloud VMs remove the git-worktree problem entirely — each agent session gets its own isolated environment, so there is no code collision to manage.
- Production write keys should live in a password manager, never handed to an agent by default — the agent has to ask for the key and the human pastes it in manually for every prod write.
- The real bottleneck at high agent volume isn't coding speed, it's the human's capacity to make roughly 10 to 20 high-stakes yes/no decisions before lunch.
- Pin only the two or three threads that matter today and let everything else run in the background — checking every thread constantly is what burns the manager out, not the agents.
- A roughly 25-minute check-in cadence keeps a solo operator sane while running many agents at once.
- About half of agent management can happen from a phone, because agents block on human decisions around the clock, not just during desk hours.
- An automated end-to-end signup test that browser-tests the real product three times a week costs about $60 in tokens and catches breakage before customers do.
- A daily automation that summarizes overnight customer activity into a report linked back to the real UI replaces manually reading logs.
- A self-improvement loop can grade an AI agent's own customer conversations against a rubric daily and auto-spin a child session to fix anything that scores low, shipping small UX fixes a human would never have bothered prioritizing.
- A $20,000 token month is what forces most builders to start routing tasks to cheaper fine-tuned models instead of running everything on a frontier model by default.
- Budget roughly $5,000 a month in tokens per 'engineering employee' once a product has real usage — above that, the fix is model routing, not a bigger budget.
- Route by task, not by habit: cheap fine-tuned models handle high-volume loop work, and expensive frontier models are reserved for genuinely hard calls.
- Building an entire company's software factory on a single frontier lab's own tool is risky long-term because that lab isn't incentivized to optimize your token bill — independent agent labs are.
- Publicly sharing what you're learning, even unpolished, compounds into relationships and opportunities over years — it's how guest bookings and business relationships actually get built.
The job changed from writing code to managing agents and routing their costs.
Scaling output now means running agents from the cloud, budgeting your decision-making capacity like a scarce resource, and routing tasks to the cheapest model that can do the job.
- A cold open can state a bold, testable claim in one sentence and immediately name the guest who will prove it — no throat-clearing needed.
- Prior management experience (people, teams, organizations) transfers directly to managing AI agents — the discipline is the same, the reports just aren't human.
- A solo operator can run a company with real paying customers and rapidly growing revenue without hiring, as long as agent management replaces headcount.
- A 52-inch monitor split into purpose-built zones (notifications, key storage, testing, agent sessions) reduces the friction of monitoring many parallel workstreams.
- Keep production write credentials in a password manager and require an agent to explicitly ask for them per task, rather than granting standing access.
- Cloud-hosted virtual machines let multiple AI coding sessions run in parallel without colliding, removing the need for git worktrees or duplicate local checkouts.
- The mental overhead of coordinating parallel local work (which files, which branch, did I pull) disappears once each agent gets its own disposable environment.
- Reaching product-market fit is often the forcing function that makes a founder abandon local development entirely — real customers require a step-change in output.
- Front-end and wireframing work may still start locally, but should move to a cloud agent as soon as possible once the shape of the feature is clear.
- Roughly half of high-output agent management can realistically happen from a phone, since agents block on human approval at all hours, not just desk hours.
- Reframe the job itself: at high agent throughput, the scarce resource is the human's capacity for high-stakes decisions, not typing speed.
- Pin only the threads carrying today's most important work, and check them on a fixed cadence (roughly every 25 minutes) rather than continuously, to avoid burnout.
- A visible PR-per-day chart is a useful gut-check for whether an agent workflow is actually shipping, not just generating activity.
- An automated end-to-end signup test that runs a few times a week in a real browser catches production breakage that unit tests miss, for a modest, bounded token cost.
- A daily automated summary of real customer activity, linked back to the actual UI, surfaces problems a human scanning logs would likely miss.
- Delegate automation-building itself to a parent agent thread that spins up cheaper child sessions, rather than hand-building every integration yourself.
- A self-graded improvement loop — grading an AI agent's own output against a rubric and auto-fixing what scores low — surfaces small UX problems a human would never prioritize fixing manually.
- There is still no substitute for a human periodically using their own product end to end; agents miss judgment calls that are obvious to a person.
- Treat a runaway token bill as a signal to add model routing, not a signal to cut usage: budget roughly $5,000 per engineering employee per month and route cheap, high-volume work to a fine-tuned model.
- Avoid anchoring an entire company's engineering workflow to a single frontier lab's own agent tool, since that lab has no incentive to optimize your long-term cost.
- Independent agent labs that sit on top of multiple models are structurally incentivized to find the cheapest model that gets an acceptable result for each task.
- Publishing what you're learning publicly, even when unpolished, is a durable way to build the relationships and credibility that later become business opportunities.
- It's fine to publicly admit you don't know something and let an agent help you figure it out — that honesty is itself part of the credibility-building.
- The three compounding skills for this era are working from the cloud, building automations, and building a public, credible reputation.
Terms worth knowing.
- Devin
- A cloud-based AI coding agent made by Cognition that runs full development sessions inside its own virtual machine, including writing, testing, and shipping code.
- Cloud agent / VM
- A disposable virtual machine spun up per coding session so multiple AI agents can work in parallel without their code changes colliding.
- Production watchdog
- A daily automation that scans a database for real customer activity and produces a summary report the founder reads each morning instead of digging through logs.
- Model routing
- Deliberately sending different tasks to different AI models based on cost and difficulty, instead of running every task on the same, usually more expensive, model.
- SWE-1.7
- A fine-tuned, lower-cost coding model built by Cognition, used for high-volume automated loop work instead of a frontier model like Opus or GPT.
- Playbook
- A saved, step-by-step set of instructions inside Devin telling an agent exactly how to correctly execute a recurring task, distinct from a one-off 'skill.'
- Independent agent lab
- A company that builds an agent product on top of multiple underlying AI models (e.g. Devin, Cursor, AMP, Factory) rather than a single frontier lab's own coding tool, letting it route work to whichever model is cheapest for the job.
- Git worktree
- A way to check out multiple branches of the same code repository locally at once; described here as a technical workaround that cloud-based agent VMs make unnecessary.
Things they pointed at.
Lines you could clip.
“I don't think it's crazy to say that the people who know how to run teams of AI agents are gonna be able to outperform everyone else in this AI age we're in.”
“You need to be the best in the world. And it doesn't matter whether you're a VC, a founder, an IC, a mom, a dad, like a college student.”
“If you are working locally, I honestly think you are a caveman.”
“They are not doing real work.”
“What your work is now is making high stakes decisions almost all day.”
“It turns out this weird back muscle, it turns out that's the most important muscle in the world.”
“It is shocking to me the number of small fine UX details that have been picked up by this loop and have been fixed.”
“For real engineering work per employee, you're looking at probably $5,000 a month. And anything more than that, you really need to figure out model routing.”
“I don't understand why anybody would build their engineering on a Frontier lab stack.”
“Take the time to share what you're learning. It doesn't have to be super polished, but get out there and be useful to people, and it will open up doors.”
Where the conversation goes.
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
The bait, then the rug-pull.
Greg Isenberg opens with a blunt claim: the people who learn to run teams of AI agents are about to outperform everyone else. His guest, Ryan Carson, has the receipts — a one-person startup shipping up to 40 pull requests a day, half of it managed from his phone.




































































