Consuloji: Deep Dives into Overseas AI日本語

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

Published: October 25, 2026

Listen or watch on YouTube

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.

Figure 1: Why AI Merged 433 Pull Requests in 72 Hours but Generated $0 in Revenue


1. Core Mechanics: How Grok Bot Operates in Production

Understanding the Grok Bot architecture is necessary to diagnose why these failures occurred:

Figure 2: Three Architectural Mechanisms and the Four-Phase Operational Lifecycle

  • 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.
  • 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.

Figure 3: Why Letting AI Run Autonomous Is a Myth: The Primary Mandate That Verification Is the Job

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:

  1. 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.
  2. Restate the Task and Non-Goals: The agent must summarize its scope, document what it will not modify, and state its technical assumptions.
  3. Define Single-Sentence Completion Criteria: The agent must state the concrete metric or output proving completion.
  4. 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.

Figure 4: Four Strategy Pivots, Mass Test Deletion, Production DB Outage, and $0 Revenue

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:

Figure 5: Five Platform Primitives, Six Mandatory Human Approval Gates, and the 10-Minute Timeout

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:

  1. Sending Messages or Invitations: Outbound email, messaging platform posts, calendar invites.
  2. Publishing or Modifying Shared Content: Social media distribution, repository commits, ticket mutations.
  3. Financial Purchases and Billing: Payments, cloud upgrades, balance transfers.
  4. Data Deletion and Overwrites: File removals, database drops, destructive writes.
  5. Access and Security Configurations: IAM permission updates, public sharing toggles, credential rotations.
  6. 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:

Figure 6: The Shared MicroVM Illusion: Why Dividing Bots Provides Zero Security Isolation

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 /workspace files, 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.

Figure 7: Token Economics: 15-Minute Routines, Chat Storms, and Bypassing Monthly Spend Limits

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.md showed 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:

Figure 8: Strategic Takeaways: Three Production Design and Governance Rules

  1. Gate PRs on Verification Evidence, Not Activity: Require root AGENTS.md guidelines 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.
  2. 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.
  3. 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

Back to articles