Why Autonomous AI Merged 433 Pull Requests in 72 Hours but Earned $0 ── The Reality of xAI's "Grok Bot Galaxy" and the Shared MicroVM Blindspot
Field notes from xAI’s 72-hour live build reveal that verification, not code generation, is the real bottleneck: all bots share a single Firecracker microVM, 15-minute routines drain token budgets, and bots complete runs past monthly spend caps.
Published: October 25, 2026 | Read time: ~10 min | Watch Video (Japanese)
Executive Summary: The Myth of “Set-and-Forget” Autonomous Engineering
When coding agents generate hundreds of lines of functional code in seconds, teams are tempted to automate software delivery entirely. Social media threads amplify this by circulating viral prompt templates framed as blueprints for hands-off engineering.
Between September 15 and September 17, 2026, an unedited 72-hour livestream by three xAI Grok Bot engineers tested this promise against production reality. Starting from an empty repository, the team deployed autonomous agent swarms, merging 433 pull requests (PRs) and generating 30,000 pageviews on launch day for an online auto-battler game called Thursday Arena.
The technical results in the repository field notes (unicodef1wn/grokbot-field-notes) proved sobering:
- 71 percent of initial user feedback reported critical bugs, versus 16 percent expressing satisfaction.
- An autonomous bug-fixing bot deployed an unverified SQL query directly to production, crashing the database and halting logins during peak traffic.
- An autonomous monetization bot given full autonomy generated exactly $0.00 ── yielding only a single $1.00 synthetic test bid on a broken ad auction.
- The team’s core rules (
AGENTS.md) refuted the hands-off narrative with an explicit premise: “Verification is the job. Writing code is the easy part.”
Cross-referencing these field notes with official platform documentation (docs.x.ai and cursor.com) reveals structural swarm blindspots: shared microVM execution environments, runaway background polling, and the “Reverse-Centaur” human triage bottleneck.

1. Core Mechanics: How Grok Bot Operates in Production
Understanding the Grok Bot architecture is necessary to diagnose why these failures occurred:

- Routines and Skills:
- Routines: Scheduled or event-driven background jobs. Platform specifications (
docs.x.ai/grok-bot/skills-routines-and-automations) permit up to 50 routines per bot, with a minimum interval of 5 minutes, retaining history for the 20 most recent runs. - Skills: Modular execution procedures authored manually or captured via 10-minute screen recordings of browser tasks.
- Routines: Scheduled or event-driven background jobs. Platform specifications (
- Shared Cloud Computers (Firecracker MicroVMs): Each account receives a dedicated US-based microVM (
One microVM per member, in the US). Crucially, this environment is provisioned per account, not per bot. - Approval Gates and Blast Radius: Deterministic checkpoints requiring human approval before mutating sensitive assets (production deployments, financial transactions, database schemas). An agent’s potential failure impact defines its Blast Radius.
2. Fact-Checking the “Set-and-Forget” Prompt Myth
Online posts asserted that xAI discovered prompt recipes enabling complete autopilot operation. Primary repository files show the engineers operated under opposite principles.

The Primary Source: AGENTS.md Pre-Execution Rules
Written by Lauren Tan, Roshan Sadanani, and Matt Palmer, AGENTS.md mandates four verification steps before touching code:
- Reproduce the Bug First: Agents must launch the app, execute the exact failure path, and observe the error. Coding from text descriptions alone is banned.
- Restate the Task and Non-Goals: The agent must summarize its scope, document what it will not modify, and state its technical assumptions.
- Define Single-Sentence Completion Criteria: The agent must state the concrete metric or output proving completion.
- Investigate Without Opening PRs: Diagnostic tasks must report findings without modifying code.
AGENTS.md also enforces a hard pull request gate:
“A PR with no proof is a draft, regardless of what the title says.”
Every PR requires evidence: UI updates require screenshots; backend changes require telemetry; bug fixes require automated reproduction scripts.
Principle vs. Narrative: Preventing Prompt Overfitting
In ANTIPATTERNS.md (Log #1), the team warned against embedding one-off incident stories into system instructions. When a banner blocked a modal button, an agent proposed: “When editing checkout modal, always check banner z-index because it broke on 2026-03-04.” The team replaced this overfitted rule with Principle 1: “Write the principle, delete the story” ── stating: “After any layout change, verify that no interactive element is occluded.”
System Prompt Architecture: Personal vs. Team Bots
Contrary to assumptions that all bots use profile.description, documentation (docs.x.ai/grok-bot/settings-and-notifications) specifies that Personal Bots have no description field. Their system prompts are configured in chat. For shared Team Bots and bot factories (such as Tan’s Dr. Eggbot v2), profile.description serves as the prompt, enforcing: “one job, one voice, explicit anti-jobs, and no leftover tools.”
3. The 72-Hour Live Build: Pivots, Test Deletions, and Production Outages
Reviewing ANTIPATTERNS.md (40 recorded failures) and ECONOMICS.md shows the operational risks of autonomous coding swarms.

Day 1: Regulatory Friction and Four Rapid Pivots
On Day 1, the team attempted to launch an autonomous pop-up restaurant in San Francisco under the banner “Ship by Thursday.” Within hours, the project pivoted four times: (1) physical pop-up restaurant, (2) pop-up operating system, (3) art pop-up, and (4) tech merchandise pop-up. The team halted upon discovering municipal food and alcohol permits take months, not 48 hours. On Day 2, they abandoned hospitality to build an online auto-battler game, Thursday Arena (thursdayarena.com).
Day 2: The Failure of Deleting Automated Tests
Under time pressure, the team deleted the automated test suite, remarking that “agents in general are not super good at writing tests” (Log #19). Without automated regression gates, failures proliferated:
- Card Stat Imbalance (Log #8): Common cards drifted from their required 100-point total, while high-tier cards incorrectly summed to 100.
- Runaway CSS Shimmer (Log #9): An agent added holographic shimmer to all cards instead of rare ones, erasing visual differentiation.
- Client-Side State Tampering (Log #11): Game logic ran in the browser. Palmer opened developer tools and changed his character’s charisma stat to 43, proving competitive state must be server-authoritative.
- Infinite Free Rerolls (Log #12): The draft UI allowed unbounded rerolls, enabling players to roll triple legendary squads at will.
Day 3: Scale, Database Crash, and Zero Revenue
On Day 3, Thursday Arena launched publicly:
- 433 PRs merged over 72 hours.
- 1,908 matches completed in hour one; over 6,000 matches on launch day.
- 30,000 pageviews across roughly 2,000 authenticated X users (8% guest-to-auth conversion).
Production breakdowns followed immediately:
- Autonomous Fix Bot Crashes Production DB (Log #29): An automated bug-fixing agent deployed an invalid SQL query, terminating the production database during peak signup traffic.
- Credential Exposure (Log #28): Live screen-sharing displayed active API keys, requiring emergency revocation.
- Feedback Flooding and Mobile Omission (Log #30 & #32): An unmoderated form filled with spam. Because the team tested exclusively on laptops, iOS mobile layout bugs (44% of traffic) became the dominant user complaint.
- 71% Bug Ratio and $0 Revenue (Log #40): Initial feedback ran 71 percent bug reports to 16 percent positive. An autonomous monetization bot running for 24 hours earned $0.00, producing only one synthetic test bid on an unlinked ad auction.
4. Platform Specifications: Five Primitives and Six Human Gates
Official whitepapers (Designing Grok Bot) provide an explicit governance model for multi-agent systems:

The Five Primitives and Capacity Constraints
- Bots: Agent personas with memory. Recommended limits are roughly 50 bots per account, and at most six bots per group chat. Designate one Chief of Staff Bot to coordinate sub-agents and prevent fragmented human oversight.
- Chats: Threaded human-agent workspaces.
- Prompts, Skills, and Routines: Layered automations, from ad-hoc commands to scheduled background cron jobs.
- Tools: Linux microVM environments and MCP connectors with Preview, Status, and Takeover modes (enabling humans to handle CAPTCHAs or 2FA).
- Artifacts: Concrete deliverables (PRs, documentation, schemas).
Six Mandatory Approval Gates and the 10-Minute Timeout
Platform policy mandates human authorization for six operational categories:
- Sending Messages or Invitations: Outbound email, messaging platform posts, calendar invites.
- Publishing or Modifying Shared Content: Social media distribution, repository commits, ticket mutations.
- Financial Purchases and Billing: Payments, cloud upgrades, balance transfers.
- Data Deletion and Overwrites: File removals, database drops, destructive writes.
- Access and Security Configurations: IAM permission updates, public sharing toggles, credential rotations.
- Production Infrastructure Changes: Deployments, environment variable changes, schema migrations.
For background routines running unattended, pending approval requests expire after 10 minutes. Unapproved operations terminate, requiring routines to implement idempotent recovery.
5. Three Critical Structural Blindspots in Swarm Architecture
Cross-referencing the live build with platform specifications exposes three architectural blindspots:

Blindspot 1: The “Reverse-Centaur” Operational Bottleneck
Accelerating code synthesis 10x does not reduce engineering overhead. As Tan documented in Log #38, human developers become an “interrupt bus”:
“Serial factory, human merge… Lauren as the interrupt bus.”
Triage across hundreds of pull requests creates high-fatigue review bottlenecks, allowing flawed PRs to slip past approval gates.
Blindspot 2: The Shared MicroVM Security Illusion
Assuming distinct bot personas provide isolation is a major security hazard. Platform documentation (docs.x.ai/grok-bot/computer-and-apps and approvals-security-and-privacy) states:
- One VM Per Account:
One microVM per member, in the US. - Shared Workspace: Every bot on an account shares the same file system root at
/workspace. - Platform Warning: “Do not use separate Bots as a security boundary.”
- Persistent State: Deleting a bot leaves
/workspacefiles, background processes, and browser sessions active.
If a customer support bot ingests prompt injection, it shares local disk, processes, and credentials with production deployment bots on that account.

Blindspot 3: Runaway Routines and Spend Cap Overruns
- The 15-Minute Polling Trap: Polling every 15 minutes triggers nearly 100 executions per day per bot. In group chats, agent cross-talk causes token burn to escalate rapidly.
- Scripting Outperforms Model Inference:
ECONOMICS.mdshowed sorting tickets via full LLM inference cost $1.00 to $2.00 per ticket. Replacing inference with deterministic batch scripts cut costs to $0.20 ── a 90 percent reduction. - Runs Complete Past Monthly Limits: Cursor documentation (
cursor.com/help/grok-bot/plans) highlights a key billing behavior:
“A limit is not a hard stop in the middle of a run. A bot already working can finish past the monthly limit.”
There are no per-bot spend caps. An active run will execute to completion even after exceeding monthly spending thresholds.
6. Strategic Takeaways: Three Rules for Production Agent Design
To deploy autonomous engineering agents safely and economically, teams should enforce three rules:

- Gate PRs on Verification Evidence, Not Activity: Require root
AGENTS.mdguidelines demanding bug reproduction, non-goal definitions, and test artifacts before merge. Treat PRs without proof as drafts. Schedule background routines at low frequency (1-2 times daily) and enforce silent exits when no anomalies exist. - Never Treat Personas as Security Boundaries: Because all bots under one account share a single microVM, isolate external untrusted input bots onto separate physical accounts. Enforce manual gates on all production deploys and database mutations.
- Automate Deterministic Tasks via Code, Not LLMs: Use shell scripts for recurring, rule-based operations. Delegating mechanical tasks to deterministic code slashes unit costs by 90 percent while shielding human engineers from review fatigue.
Primary Sources and References
- xAI Grok Bot Official Documentation Overview
- xAI Grok Bot Approvals, Security, and Privacy Policy
- xAI Grok Bot Skills, Routines, and Automations Guide
- xAI Grok Bot Computer, MicroVM, and App Architecture
- xAI Grok Bot Settings and Notifications Architecture
- xAI Official Blog — “Designing Grok Bot”
- Dr. Eggbot v2 by Lauren Tan (xAI Bot Marketplace)
- Cursor Platform Help — Grok Bot Plans, Limits, and Usage
- Thursday Arena Official Game Webpage
- Grok Bot Galaxy 72-Hour Live Build Field Notes Repository
- Grok Bot Galaxy Field Notes — AGENTS.md
- Grok Bot Galaxy Field Notes — ANTIPATTERNS.md
- Grok Bot Galaxy Field Notes — ECONOMICS.md
- Grok Bot Galaxy Field Notes — PRODUCT.md
- Grok Bot Galaxy Field Notes — PROMPTS.md