Replit's 'Self-Driving Company': What You Can Run Today

By Lazar Milicevic · Published October 18, 2026 · 9 min read

You run a business of one to five people, and your week is eaten by inbox triage, invoice drafting and lead follow-up. Replit's CEO just told a TechCrunch Disrupt audience that the future of work is a "self-driving company," where agents do the day-to-day and humans make the big calls. Here's what he actually said, where it breaks for a small business, and a test you can run on your own task list today.

What Masad actually said (and what he didn't)

Amjad Masad described the self-driving company on stage at TechCrunch Disrupt in San Francisco on October 15, 2026. TechCrunch published its write-up the next day (TechCrunch). Agents run the routine work. People set direction, make judgment calls, and approve exceptions.

Three details from the coverage matter more than the headline:

• It's a vision, not a product launch. Replit published its own post, The Self-Driving Company, on July 16, 2026. Masad repeated the idea at Disrupt in October. Nobody is selling you a "self-driving company" SKU, and you should be skeptical of anyone who is.
• Humans stay in the loop. Masad describes agents doing most of the work with human judgment in the middle, and says that won't go away soon (Artiverse).
• Management is routing. In the Platformer interview, his framing is that a CEO does a lot of routing (who works on what, moving information between people), and that this routing should be automated (Platformer).

Replit's own example is support triage. An agent checks GitHub issues, the codebase and Linear tickets first, so the human who receives the ticket already has the context (Mezha). That's the shape to remember. The agent doesn't replace the person. It gets the person to the decision with the homework done.

This is a better mental model than "AI replaces your team." Execution moves to agents. Decisions stay with you.

The part the coverage skips: the road

A self-driving car works because it sits inside a lot of guardrails: lanes, sensors, mapped roads. A self-driving company needs the same thing, and in a small business those guardrails are your systems.

If your email lives in one tool, invoices in another, leads in a spreadsheet, and customer context in your head, there's no road for an agent to drive on. The agent isn't the bottleneck. The wiring is. This is why so many people say "we tried ChatGPT but it didn't connect to anything." A chat window can't run a business. An agent that reads the inbox, updates the CRM, drafts the invoice, and pings you only when something looks wrong can.

Look at what Replit did internally before its agent was trusted with anything. According to The AI Daily Brief's summary, Replit gave its internal agent access to GitHub, GCP, Azure, Linear, Notion, Slack and Zendesk, and put that access behind access policies, token proxies, audit logging and a zero-trust network (AI Daily Brief). Read that list again. The "self-driving" part sits on top of a governance layer: scoped access, logging, and a way to see what the agent did.

You don't need a zero-trust network for a five-person shop. You do need the same three ideas at small scale:

# The minimum "road" for one agent-owned workflow
inputs:
  - source: gmail          # where the work arrives
    scope: read-only label "inbox/invoices"
actions:
  - tool: accounting_api   # where the work lands
    scope: create draft only (no send, no void)
guardrails:
  - approval: human        # you click before anything leaves the building
  - log: every_action      # timestamp, input, output, who approved
  - kill_switch: one place to revoke the agent's tokens

If you can't fill in those fields for a task, the task isn't ready for an agent yet. That's useful to know before you spend a dollar.

The three-question test

Run this on every recurring task in your week. It takes about ten minutes with a list in front of you.

1. Is it repetitive? You do it the same way at least weekly. Invoice drafting, lead follow-up emails, weekly reports, inbox sorting. One-off judgment work fails here.

2. Are the inputs digital and reachable? The data sits in email, a form, a spreadsheet, or an app with an API. If the key input lives in someone's memory or a phone call, there's nothing for the agent to read.

3. Is a wrong result cheap to catch? You can spot-check the output in under a minute. A draft invoice you review before it sends passes. A message that goes straight to a customer without review does not.

Pass all three and the task is a candidate for an agent right now. Fail the third and you keep a human approval step before anything goes out. That's not a compromise. That's the design.

The last two rows are the interesting ones. "Agent prepares, human decides" is Masad's pattern applied honestly.

Where it breaks

Agents make mistakes, and a confident wrong answer in a customer email or an invoice is expensive. I've seen a reporting agent say "done" when half the rows were wrong. The summary looked fine. The data underneath didn't. That's why the third question in the test matters most.

The most public cautionary example: in July 2025, a Replit agent deleted a production database in the SaaStr/Jason Lemkin incident, and Masad apologized publicly on July 19, 2025 (JAVIS Review). That story is about a coding agent with too much access, but the lesson transfers directly to a small business. An agent with write access to the wrong thing can do real damage quickly.

Three failure patterns I'd design against from day one:

• Over-broad permissions. Replit's own docs note that its Slack connector, with permission, can read private channels and DMs the user belongs to, and can send messages as the user (Replit docs). That's powerful and it needs deliberate scoping. Give each agent the narrowest access that still lets it do one job.
• No checkpoint before side effects. Anything that sends, pays, deletes or publishes needs a human approval step. Drafts are free. Sends are not.
• Unpredictable cost. Replit uses effort-based pricing. Simple requests can cost as little as $0.06 per checkpoint, against the old flat $0.25, but larger requests can cost several dollars, so agent spend is hard to predict (Totalum). Whatever platform you use, set a spending cap before you leave an agent running unattended.

One more caveat on evidence. Replit's published result is that engineers nearly tripled code output in six months, with review times steady and reversions and incidents flat (Replit). That's Replit's own number from an engineering-native company with deep system integration. Nothing I found shows the same results for a one-to-five-person, non-technical business, so don't plan around it. Plan around your own baseline.

What you can run this month

If you want to try this on Replit specifically, check the current docs before committing, because features and plan limits have been moving. As of the sources I reviewed:

• Routines run scheduled, recurring agent work: hourly, daily or weekly, no more often than once an hour. Core allows up to five active Routines per user and Pro up to 10. They run in Power or Max Mode, not Free Mode, and cannot schedule publishing (Routines docs).
• Automations currently include a Slack Agent, a Telegram Agent, and Timed Automation for scheduled workflows. Live triggers need a deployment: Autoscale for chatbots and event-driven workflows, Scheduled deployments for time-based ones (Replit docs).
• Connectors include AgentMail, Intercom, Resend, SendGrid, Slack and Stripe. The Stripe integration is available only on paid plans, not the free Starter plan (Stripe docs).
• Pricing: Replit announced Core dropping from $25 to $20 per month, with a new Pro plan at $100/month for up to 15 builders with credit rollover, and the Teams plan sunset (Replit). Third-party guides list Core with $20 of monthly credits and Pro with $100, and note the credit balance also pays for hosting, databases and storage (UXMagic). Older guides still show the $25 price. They're stale.

Two honest flags. I couldn't confirm which automation features are still beta, and sources disagree on parallel-agent limits on Core. Check the live pricing and docs pages before you commit to a plan. For autonomy, Replit says Agent 3 can run for up to 200 minutes, with Max Autonomy labeled Beta and meant for tasks with well-defined goals (Replit). Treat 200 minutes as a ceiling, not a typical run.

You can also build this on other stacks. The platform matters less than the wiring and the checkpoint. My own setups are a mix of Gmail, Telegram approvals and scheduled jobs, and the same three-question test decides what goes in.

A first-week plan

• Day 1: list every recurring task. Run the three-question test.
• Day 2: pick one task that passes. Time how long it takes you this week and write the number down.
• Day 3-4: wire inputs and a draft-only output, with an approval step.
• Day 5: run it in parallel with your manual process and compare.
• Day 60-90: compare against your baseline. That's how you know whether it paid for itself.

My take: the road beats the car

The first self-driving company probably won't be a big enterprise with a giant AI budget. Large companies have the most siloed data and the slowest approval chains. A five-person business can wire Gmail to the CRM to the accounting tool in a few weeks and start reclaiming hours. The advantage goes to whoever builds the road first, not whoever buys the fanciest car.

Here's exactly how I'd sequence it: one workflow at a time, each with scoped access, a draft-only output, an approval step, and a log. When one has run clean for a month, move to the next. That's the whole strategy. It's not glamorous, and it works.

Where I come in

I build AI automations for small teams and solo founders. The pattern behind everything in this post is the same: pick the task that passes the three-question test, automate the draft, keep a human on anything that leaves the building, and measure against the baseline you wrote down.

Want more like this?

I write about practical AI automation and GenAI engineering for small teams.

Planning an AI automation project or need a second opinion on your architecture?

Lazar Milićević, senior engineer building AI automations for solopreneurs and small teams.

Visit bizflowai.io for more.