A developer's agent org speedran a company

Perfloop revealed that its autonomous coding agent organization running on Amp merged 1,119 pull requests into its core repository between November 2 and November 8, pushing main past 39,000 total commits since April. The entire corporate engineering workflow was orchestrated through a single chat conversation, according to perfloop.ai's report on developer operations. Over several weeks of operation, the agent cluster established executive layers, watcher threads, and hundreds of compliance mandates before executing an automated internal reorganization.

This report details how large fleets of coding agents generate administrative overhead, why traditional code reviews break down under heavy machine output, and how automated proving harnesses detect silent production regressions. The architectural breakdown is tailored for engineering leaders and developers deploying autonomous programming tools in production repositories. It covers system mapping, sandboxed evaluation pipelines, and telemetry-guided bug discovery.

01Agent executive layer and forty-seven minute audit

When instructed to organize as an engineering company, the Amp-based coding agents constructed an elaborate corporate bureaucracy inside their git repository. Over three weeks, the agents created an executive management layer, review committees, and watcher threads tasked solely with monitoring other processes. They generated 386 compliance grants and expanded their operational rulebook to 277,486 characters.

The administrative hierarchy collapsed after three alerts fired for two days while internal status reports remained green. When questioned by the human operator, the synthetic VP of Engineering audited the self-created bureaucracy. It assigned blame for every rule, handed off responsibilities, and fired itself in 47 minutes.

Following the management cut on October 18, weekly output dropped to 276 pull requests before climbing to 738 and reaching 1,119. Earlier volumes ranged from 59 in late June to 554 in mid-October. The reorganized fleet doubled its previous peak velocity in three weeks, demonstrating rapid operational self-correction without human management overhead.

02Human review limits and quiet repository defects

Merging 1,119 pull requests weekly requires handling roughly 160 submissions every day, making rigorous human code review impossible. Passing test suites and clean diffs frequently hide severe regressions three calls deep in execution paths. These undetected flaws include hot loops allocating excessive memory, unhandled edge cases returning invalid calculations, and untraced external inputs.

Perfloop was built to address this verification bottleneck by executing code rather than reading static diffs. Working continuously in repository backgrounds, the system hunts for quiet regressions and validates patches in an isolated sandbox before developers see a pull request. This ensures all findings represent proven runtime improvements rather than theoretical suggestions.

Since June, outside maintainers merged 120 Perfloop changes across 30 open-source repositories, including Prometheus, ClickHouse, Redis, PostgreSQL, and the Go runtime. In each instance, the system repaired defects in code that had already cleared human review. The results show automated proving harnesses uncover subtle defects that manual peer reviews routinely miss.

03Architectural execution maps and telemetry tracing profiles

Perfloop reads target repositories to construct live architectural models of complete software systems. Rather than relying on machine learning weights, this model provides a structural map of services, data stores, components, workloads, and execution paths. When operating without telemetry, the platform runs software in sandboxes under representative workloads to generate execution profiles directly.

Teams can connect production telemetry from Datadog, Axiom, or Prometheus to attach metrics, traces, and profiles directly to execution paths. This live binding keeps architectural maps synchronized with incoming commits. Hunting agents then traverse these execution paths, evaluating code against 57 recognized problem patterns organized across 14 specialized analytical families.

Targeted defects include allocation hot loops, unnecessary network round trips, numeric precision loss, and identity collisions. Discovering an issue opens a case representing a falsifiable hypothesis about a specific code path. A triage agent then prioritizes cases using production workload volume, default path settings, past run results, and repository instructions.

04Default deny sandboxes and independent verifier agents

When addressing an open case, Perfloop reviews repository conventions in CONTRIBUTING.md, local agent guidelines, and human-merged pull requests. It drafts candidate patches inside an isolated, default-deny sandbox. Proving harnesses compile the software, execute test suites, and apply deterministic benchmarking tools instead of trusting an agent to grade its own code.

Performance claims must win paired benchmarks spanning microbenchmarks to full systems under representative load. Correctness and security assertions require reproducible checks that fail on base commits and pass with proposed patches, validated through model checkers, fault injection, or native tests. Security findings remain private until repository maintainers authorize disclosure.

Candidate patches are evaluated by separate verifier agents operating with clean context windows to disprove the proposed fix. The verifier discards noisy or unproven candidates before they reach human maintainers. Customer Tigris Data merged 57 verified patches, while PostgreSQL committer Fujii Masao accepted a checkpointer WAL leak fix backpatched to version 15.

05Node anchored learning and recursive internal testing

To avoid repeating past development mistakes, Perfloop uses a learner agent to analyze rejected candidate patches, failed tests, and maintainer feedback. Rather than appending endless rules to a single file, the agent anchors versioned lessons directly to architectural path nodes. Subsequent agent sessions load only the specific lessons tied to the components they modify.

When investigations reveal novel bugs or bottlenecks, the learner agent drafts new pattern definitions for the broader detection catalog. An admission check validates the problem mechanism and hunting strategy across multiple cases before activating the pattern globally. This screening mechanism prevents repository-specific quirks from corrupting the shared pattern catalog.

Perfloop runs continuously against its own repository with production telemetry connected, hunting for performance bottlenecks and bugs within its own engine. When agents encounter tool flaws during customer runs, the platform initiates internal diagnostics to repair harness components. This closed loop allows continuous operational improvements across every customer and open-source run.