AGENTCONN

Field report · · AgentConn Team

The Software Factory Is Here

How agent-native engineering orgs actually operate: Cognition's 40x PR growth, the converging open-source stack, and what changes.

AI AgentsSoftware FactoryAgent-Native EngineeringCode ReviewDeveloper ToolsOpen Source

The Software Factory Is Here

A futuristic digital software factory floor with glowing agent nodes working in parallel on assembly lines while orchestrator figures oversee from elevated platforms

The software factory stopped being a metaphor sometime around March 2026. At Cognition, Walden Yan reported that the company merged 40x more pull requests while growing its engineering headcount by just 2.7x. At PostHog, agents now open roughly 70% of monorepo PRs — up from 20% four months earlier. At Gumloop, 571 agent-written PRs merged in six weeks after the team restructured around Devin bots as first-class workers.

These numbers are not what make the story interesting. What makes the story interesting is the organizational structure that produced them. These companies did not just add more agents to the same team shape. They rebuilt how engineering work is defined, delegated, reviewed, and shipped. The result looks less like a traditional software team and more like a manufacturing floor — with orchestrator humans, agent workers, verification gates, and a continuous delivery pipeline that runs whether anyone is at their desk or not.

This is the agent-native engineering org. Not “AI-assisted” — where humans write code and agents suggest completions. Not “AI-augmented” — where agents handle tickets while humans review every line. Agent-native means the organization was designed from the start (or redesigned from scratch) around the assumption that most code will be written by agents, most of the time.

Joe Lonsdale tweet: Cognition merged 154 Devin PRs in best week of 2025, 659 PRs last week — Devin sessions growing even faster across enterprise customers

View original post on X →

The Cognition Blueprint: What 40x Actually Looks Like

The headline number — 40x more merged PRs — comes from Walden Yan’s talk at AI Engineer 2026. The breakdown matters more than the aggregate.

Cognition’s internal data shows the progression: 154 Devin PRs in their best week of 2025, growing to 659 PRs per week by early 2026, with 89% of all code committed by Cognition engineers now coming through Devin. The team itself grew from roughly 30 to about 80 engineers over the same period — the 2.7x headcount multiplier.

But the organizational shift is what made the throughput possible. Cognition runs what they call a “pod” model: small teams of 2-3 humans managing a swarm of Devin instances through Slack. Each pod owns a product area. The humans define intent — what should happen, what the acceptance criteria are, what the edge cases look like. The Devins execute. When a Devin gets stuck, it escalates through Slack. When a PR is ready, it enters a verification pipeline that includes both automated checks and human intent review.

The key insight from Yan’s talk is that Cognition struggles to find code in its own repository that was not written autonomously by Devin. The codebase has become, in effect, a factory output. The engineers who built it are no longer craftspeople writing each line — they are process engineers designing the system that produces the code.

Scott Wu, Cognition CEO, sharing Devin's internal usage data and the trajectory of agent-authored code at Cognition

View original post on X →

The Emerging Stack: From Harness to Delivery

The software factory is not just an organizational pattern — it is also a technology stack that is converging in the open. Here is what it looks like in November 2026, traced through what is trending on GitHub:

Layer 1: The Harness. The agent loop itself — how an agent receives a task, accesses tools, executes code, and returns results. Claude Code has crossed 300k stars and become the reference implementation for how a harness should constrain and enable an agent. The harness is the atomic unit of the factory floor — without a reliable harness, nothing above it works.

Layer 2: Orchestration. One agent is a tool. Ten agents are a fleet. The orchestration layer manages which agents run, in what order, with what context, and what happens when they conflict. Frameworks are formalizing the patterns that teams like Cognition built internally: task decomposition, agent routing, conflict resolution, and rollback. The agent-of-agents problem is the central challenge here.

Layer 3: Skills. The reusable capabilities that agents load on demand — project-specific workflows, review checklists, deployment procedures, testing strategies. The superpowers pattern (320k+ stars in the last 30 days) shows what happens when skills become a first-class concept: agents stop being general-purpose and start being specialized workers on the factory floor. This is the skills marketplace crystallizing into infrastructure.

Layer 4: Delivery and Review. The final gate before code ships. Alibaba’s Open Code Review (10.5k+ stars) pairs deterministic static analysis with an LLM agent to create a review pipeline that caught roughly one million defects inside Alibaba Group. This is not a code review tool — it is a quality gate for the factory’s output.

The Stack at a Glance
Harness (agent loop) → Orchestration (fleet management) → Skills (reusable capabilities) → Delivery (review + quality gates). Each layer is seeing open-source convergence. The gap is not in the tools — it is in the organizational patterns that connect them.

Code Review Becomes Intent Alignment

The most underrated shift in agent-native orgs is what happens to code review.

In a traditional team, code review serves three purposes: catching bugs, sharing knowledge, and verifying that the implementation matches the intent. When agents write 70-89% of the code, the first two purposes largely evaporate. Agents do not need to learn from review comments. And bug detection at the line level is increasingly handled by automated verification — the same static analysis and test suites that agents already run before submitting a PR.

What remains is intent alignment: does this code do what we actually wanted? Is the architectural approach sound? Does this change fit the broader system design? Are the edge cases the right edge cases?

This is a fundamental role change. Addy Osmani captured it in his Factory Model essay: “Generation is not the bottleneck anymore. Verification is.” But even that understates the shift. The bottleneck is not just verification in the technical sense (does it work?) — it is verification in the strategic sense (is it the right thing?).

Addy Osmani's Factory Model blog post: The Factory Model — How Coding Agents Changed Software Engineering

Read the full essay on addyosmani.com →

Alibaba’s Open Code Review illustrates the split. Its deterministic pipeline handles the mechanical checks — style, security patterns, common anti-patterns. The LLM agent handles the judgment calls — does this implementation approach match the described intent? Is there a simpler way? The human reviewer, when one is needed, focuses exclusively on the question that neither the pipeline nor the agent can answer: should we be doing this at all?

AGTP analysis: Cognition launched Devin Bots — always-on AI engineers that lead teams of agents, from writing firmware to merging thousands of PRs a week

View original post on X →

A Greptile analysis of 470 PRs found that logic and correctness findings were 75% more common in AI-authored PRs than in human-authored ones. This is not because agents write worse code — it is because agents optimize for passing the tests they are given, and those tests often encode incomplete specifications. The review layer’s job in an agent-native org is to catch the gaps between what was specified and what was needed.

The Contrarian Corner
Here is the uncomfortable question: if 89% of your code is written by agents and human reviewers are only checking intent alignment, who catches the class of bugs that fall between "test passes" and "intent was correct"? This is the verification debt problem — and nobody has solved it yet. PostHog reports that humans still skim 80% of agent PRs, which suggests that "intent-only review" is an aspiration, not a practice, even at the most aggressive adopters. The 40x PR numbers may be vanity metrics hiding a new category of tech debt that surfaces only when the system reaches edge cases no spec anticipated.

The Org Chart Rewrites Itself

What does the team structure actually look like in an agent-native org? The pattern emerging from Cognition, StrongDM, Gumloop, and Pipedrive converges on three roles:

The Orchestrator — formerly the senior engineer or tech lead. This person designs the agent workflows, defines the task decomposition, sets up the verification gates, and handles escalations. They spend most of their time in Slack, Linear, or a fleet management tool — not in an IDE. Patrick Debois’s AI Engineer talk makes the point that Conway’s Law applies to agent fleets just as it applies to human teams: the shape of the organization constrains the shape of the software, and adding agents does not exempt you from organizational design.

The Spec Writer — formerly the product manager or product engineer. In a factory model, the spec is the most leveraged artifact. As Osmani puts it: “Agents cannot clarify requirements they are never given.” A vague spec multiplied across ten parallel agents produces ten flavors of wrong. The spec writer’s job is to produce unambiguous, testable, complete specifications — the blueprints that the factory floor consumes.

The Verifier — a new role that did not exist before agent-native orgs. Part QA, part architect, part auditor. The verifier’s job is to review agent output not for correctness (the automated pipeline handles that) but for strategic fit, architectural coherence, and the kind of subtle wrongness that passes all tests but degrades the system over time. This is the person who notices that an agent refactored a module in a way that technically works but breaks the team’s mental model of how the system is structured.

Nader Dabit’s observation in his Substack piece captures the direction: at Cognition, 70% of Devin sessions are currently started by a human, but he predicts that will flip to 90% automated within a year. When that happens, the orchestrator and verifier roles become full-time jobs, not side duties. The spec writer becomes the highest-leverage person on the team.

Nader Dabit Substack: Engineering for Agents That Never Sleep — 70 percent of Devin sessions are human-started today, predicted to flip to 90 percent automated

Read the full post on Substack →

The Safety Substrate: Sandboxes as Table Stakes

None of the above works without isolation infrastructure.

Thoughtworks put “Sandboxed Execution for Coding Agents” on the Technology Radar in April 2026, treating it as a sensible default rather than an optional extra. The recommendation: isolated environments with limited file access, controlled network connectivity, and bounded resource usage.

The practical argument is straightforward. As Upstash’s engineering blog put it: “Twenty agents on one machine are not twenty workers, they are twenty ways to break the same checkout.” Each agent in a factory needs its own sandbox — its own filesystem, its own git worktree, its own set of environment variables, its own network constraints. Without this, the factory’s throughput is limited by the blast radius of its worst agent.

The security argument is equally direct. Graham Brooks documented how more context and tool access make agents more capable but also riskier. The February 2026 Cline VS Code extension compromise demonstrated that prompt-injection risk in coding agents is not theoretical — it is a supply-chain problem. Sandbox-first architecture is the minimum viable safety posture for any org running agent fleets.

Sandbox Checklist for Agent-Native Orgs
Per the Thoughtworks Radar and Upstash engineering guidance:
- One sandbox per agent instance (not per agent type)
- Read-only access to shared resources by default
- Network egress restricted to known endpoints
- Git worktree isolation (agent A's bad merge doesn't contaminate agent B)
- Resource bounds: CPU, memory, disk, and execution time limits
- Credential injection at runtime, never baked into the sandbox image

The Investor Signal: Capital Follows the Factory

The venture capital community has noticed. Chamath Palihapitiya, one of the most visible tech investors, flagged the convergence explicitly: as model costs converge, the next value layer is the independent harness and control plane — the factory infrastructure itself.

Chamath Palihapitiya on X: As model costs converge, the next likely step will be independent 3rd party harnesses and control planes like 8090 Software Factory, Palantir, Hermes

View original post on X →

This is not just commentary. Factory raised $200 million at a $5 billion valuation in September 2026. Cognition’s most recent raise valued the company north of $26 billion. The capital is flowing not to model labs but to the companies building the production infrastructure around them — the harnesses, the orchestration layers, the review pipelines, and the sandbox environments that make agent fleets viable in production.

Factory and Cognition: The Arms Race

The clearest signal that the software factory is real infrastructure, not a blog-post concept, came in October 2026 when Factory and Cognition shipped competing tools to run agent fleets — eleven hours apart.

Factory released Environments: a managed infrastructure layer where each agent gets its own isolated execution context. Cognition released Dynamic Workflows: a planning layer where an orchestrator agent decomposes tasks and delegates to a team of Devins.

The architectural split is revealing. Factory started from the infrastructure up — give agents safe, reproducible environments, and the orchestration patterns will emerge. Cognition started from the workflow down — define the planning and delegation model, and the infrastructure follows. The fact that both companies converged on agent fleet management as the product category confirms what practitioners already knew: the single-agent era is over. The factory is the product.

Devin Bots — Cognition’s latest evolution — formalize this further. A Devin Bot is an always-on supervisor agent that manages a team of Devin workers. It finds work (bugs, cleanup, refactoring) within a product area, opens small PRs for each change, and runs continuously. The Software Factory template is one of Devin Bots’ default configurations.

What This Means for You

If you are running an engineering org in 2026, here is the practical framework:

You are agent-augmented if: Agents help individual developers write code faster. Your org chart has not changed. Code review works the same way it always has. You are getting 2-3x individual productivity gains.

You are agent-native if: Agents are first-class team members with their own work queues. Your review process has split into automated verification and human intent alignment. You have sandbox-per-agent infrastructure. Your team roles have shifted toward orchestration and specification. You are seeing 5-40x throughput gains at the team level.

The gap between these two states is not technical — it is organizational. The tools exist. Claude Code, Devin, Cursor, Codex — the harness layer is mature. Open Code Review, Greptile, CodeRabbit — the review layer is converging. The sandbox primitives are well-understood. What most teams are missing is the org-design work: redefining roles, restructuring review norms, investing in specification quality, and building the verification pipeline that makes high-throughput agent work trustworthy.

Three Moves to Make This Week
1. Audit your review layer: What percentage of review time is spent on correctness vs. intent alignment? If it is mostly correctness, those checks should be automated.
2. Count your sandboxes: If multiple agents share one development environment, you are one bad merge from a fleet-wide outage.
3. Write one spec the way a factory needs it: Unambiguous acceptance criteria, explicit edge cases, testable assertions. If your agents keep producing wrong output, the spec — not the model — is usually the bottleneck.

The Road Ahead

The software factory is not the end state. It is the first organizational pattern designed for a world where code generation is cheap and verification is expensive. The teams that figure out the verification layer — not just automated testing, but intent alignment, architectural coherence, and strategic fit — will define what engineering organizations look like for the next decade.

The tools are open-source. The patterns are emerging. The question is no longer whether the software factory works. It is whether your organization is ready to operate one.

The AgentConn Weekly

Weekly digest of new AI agent releases, framework comparisons, and deployment guides. Built for builders.

Weekly. Unsubscribe anytime.

Explore AI Agents

Discover the best AI agents for your workflow in our directory.

Browse Directory