August 12, 2026 11 min to read

Real Autonomous Factories: software-factory.dev, Ona Sessions, and Memo

How Leading Teams Built Self-Driving Codebases: Lessons from Gitpod and Anthropic

Image credit: Coders Lab

Real Autonomous Factories: What Actually Works

TL;DR — Three production autonomous factories exist today: Gitpod’s software-factory.dev (building Memo, a Figma-to-app tool), Ona’s Sessions (internal development system), and Anthropic’s internal factory (building AI tools). All three prove autonomous factories work at scale. Gitpod’s metrics: 688 autonomous PRs, 77,424 lines of generated code, 88% autonomous rate, 100% CI green.

Let’s examine three real, production-grade autonomous factories and learn how they’re built.

Case Study 1: Gitpod’s software-factory.dev (Building Memo)

Project: Memo — A Figma design to functional React app generator
Timeline: 2 months
Team: 4 engineers (steering agents) + AI agents (writing code)
Result: 688 PRs merged, 77,424 lines of code, 88% autonomous

The Architecture

Figma Design (Input)
  ↓
[Design Parser Agent]
  Extracts: components, layout, colors, typography, interactions
  ↓
[Code Generator Agent]
  Generates: React components, TypeScript types, CSS-in-JS
  ↓
[Test Generator Agent]
  Creates: Component tests, integration tests, E2E scenarios
  ↓
[Reviewer Agent]
  Validates: Accessibility (WCAG), Performance, Type safety
  ↓
[Integrator Agent]
  Builds, tests, deploys to staging
  ↓
[Vercel Deploy]
  Auto-deploys to production on approval

Key Metrics

Agent Breakdown

Design Parser Agent

• Reads Figma API
• Extracts component hierarchy
• Identifies: buttons, forms, modals, cards, lists, tables
• Maps: colors, spacing, fonts
• Detects: interactive states (hover, active, disabled)

Code Generator Agent

• Generates React component files
• Creates TypeScript types from design intent
• Applies Tailwind CSS classes
• Implements: state management, event handlers
• Adds: accessibility attributes

Test Generator Agent

• Creates Jest unit tests (component rendering, props)
• Creates Playwright E2E tests (user flows)
• Tests: responsive design (mobile, tablet, desktop)
• Tests: accessibility (keyboard navigation, screen readers)

Reviewer Agent

• Checks TypeScript compilation (strict mode)
• Validates React best practices
• Scans for accessibility violations
• Tests: performance (component render time)
• Reviews: security (no XSS, CSRF exposures)
• Measures: test coverage (>80% required)

Integrator Agent

• Runs full test suite (unit + E2E)
• Builds production bundle
• Analyzes bundle size
• Deploys to Vercel staging
• Runs smoke tests on staging
• If all pass: promotes to production

The 12% That Needed Humans

12% of PRs needed human review. Why?

1. Edge cases (40% of interventions)
   • Unusual design patterns not seen before
   • Complex interactions requiring domain knowledge
   • Accessibility edge cases
2. Business logic (35% of interventions)
   • Feature prioritization (should we build X first?)
   • Architectural decisions (monolith vs. microservices)
   • API design choices
3. Design polish (15% of interventions)
   • Typography refinement
   • Color contrast adjustments
   • Animation timing
4. Integration (10% of interventions)
   • Connecting to existing backends
   • Third-party service integration
   • Database schema mapping

The pattern: Agents handle implementation perfectly. Humans handle judgment calls.

Key Success Factors

1. Clear input specification — Figma designs are unambiguous
2. Constrained output space — React components have known patterns
3. Automated quality gates — Tests and linters catch mistakes
4. Fast feedback loop — Agents see results in minutes, not days
5. Continuous learning — Failed PRs teach agents new edge cases

Case Study 2: Ona’s Sessions System

Purpose: Internal development platform for building backend services
Scale: 50+ engineers steering agents
Deployment: 200+ microservices across infrastructure
Result: 60% reduction in development time, 40% fewer production incidents

How It Works

An engineer requests:

Need: "User authentication microservice with JWT, rate limiting, and audit logging"

Sessions system:

1. Plans the service — 5 microservices, 3 databases, 2 message queues, 4 Redis caches
2. Generates all code — Service, handlers, models, tests, docs
3. Sets up CI/CD — GitHub Actions, SonarQube, security scanning
4. Deploys infrastructure — Terraform, Kubernetes manifests, monitoring
5. Monitors in production — Error tracking, performance alerts, incident response

Result: Complete, production-ready microservice in 2 hours instead of 2 weeks.

Architecture

Specifications
(text description of what to build)
  ↓
[Planning Agent]
├─ Breaks into services
├─ Designs database schema
├─ Plans message flows
└─ Lists all artifacts needed
  ↓
[Builder Agents]
├─ Generate Go/Node services
├─ Create database migrations
├─ Write API handlers
├─ Generate tests (unit + integration)
└─ Create deployment manifests
  ↓
[Integration Agents]
├─ Run linting
├─ Execute test suite
├─ Build Docker images
├─ Deploy to staging K8s cluster
└─ Run smoke tests
  ↓
[Reviewer Agents]
├─ Security scanning (SAST, dependency check)
├─ Performance profiling
├─ Documentation completeness
└─ Compliance (SOC 2, HIPAA, etc.)
  ↓
[Deployment Agents]
├─ Deploy to production
├─ Monitor for 24 hours
├─ Auto-rollback if issues
└─ Mark complete

Real Metrics from Ona

Why This Works

1. Standardized patterns — All services follow Ona’s conventions (same database patterns, same logging, same error codes)
2. Automated validation — Compilation, linting, security scanning all automatic
3. Safe rollback — Old versions tagged and ready to deploy instantly
4. Observability built-in — Every service has logging, metrics, tracing from day one
5. Library integration — Agents know all approved libraries and dependencies

Case Study 3: Anthropic’s Internal Development System

Scope: Internal AI research tools and infrastructure
Public Info: Limited (internal system), but publicly discussed at conferences
Known Facts: Used to accelerate Claude model development, training infrastructure
Impact: Enabled rapid experimentation with new architectures and model configurations

What’s Known

From public talks:

• Uses AI agents to generate Python research code
• Validates experimental configurations (model size, training parameters, data pipelines)
• Automatically runs experiments and analyzes results
• Generates research notebooks and analysis
• Reports findings and suggests next experiments

Example workflow:

Researcher: "Test attention head pruning on model variant 2"
  ↓
System generates all code needed
  ↓
Runs experiment (24+ hours)
  ↓
Analyzes results
  ↓
Generates research notebook with findings
  ↓
Recommends next experiments based on results

Why Internal Teams Matter

Many of the best autonomous factories are internal tools, not public products:

• Google uses AI to generate internal infrastructure code
• Meta uses agents for Llama model training and evaluation
• OpenAI uses agents for model fine-tuning and deployment
• DeepMind uses agents for experiment orchestration

These teams don’t publish details (competitive advantage), but their existence proves autonomous factories scale to the largest tech companies.

Common Patterns Across All Three

1. Incremental Adoption

All three started small:

• Gitpod: Started with code formatter, added generator, added reviewer
• Ona: Started with deployment automation, added service generation, added testing
• Anthropic: Started with experiment runners, added code generation, added analysis

Lesson: Don’t try to automate everything at once. Start with the highest-ROI task.

2. Quality Gates Are Sacred

None of the three skip testing:

• 100% code coverage required (or >95%)
• Security scanning on every change
• Performance regression detection
• Accessibility validation

Lesson: Autonomous doesn’t mean “skip quality checks.” It means “checks are automated.”

3. Humans Still Steer

Despite high autonomy rates:

• Gitpod: Humans approve major architectural changes
• Ona: Humans prioritize which services to build next
• Anthropic: Researchers still validate findings

Lesson: Humans move from implementation to strategy.

4. Rollback Always Available

All three can instantly rollback:

• Gitpod: Deploy previous Vercel version in <1 minute
• Ona: Deploy previous Docker image to K8s in <1 minute
• Anthropic: Revert to previous training configuration instantly

Lesson: Autonomy is safe when rollback is fast.

5. Feedback Loops Are Short

• Gitpod: Agent feedback in minutes
• Ona: Agent feedback in hours
• Anthropic: Agent feedback in 24 hours

Lesson: Faster feedback → better agent learning → better code generation.

The Economics: Why Build Autonomous Factories

Cost Structure

ROI Example: 50-person engineering team

Traditional factory:

• Annual feature output: 2,500 features/year
• Cost per feature: $60K (developer salary, benefits, tooling)
• Total cost: $150M

Autonomous factory:

• Annual feature output: 12,500 features/year (5x more)
• Cost per feature: $12K (agents are cheaper, less debugging)
• Total cost: $150M

Result: Same cost, 5x output

Or alternatively:

• Keep output constant, reduce team from 50 to 10
• Annual savings: $120M
• Same feature velocity with 80% fewer people

Getting Started: Learn from Their Choices

If You’re Starting Small (< 20 people)

Model after: Gitpod (start with code generation, not full autonomy)

Start with:

1. Linting and formatting automation (easiest)
2. Test generation (medium)
3. Code generation for boilerplate (harder)
4. Code review automation (last)

If You’re Building Microservices

Model after: Ona (standardize, then automate)

Prerequisites:

1. Standardized service patterns (all services look similar)
2. Standardized database schemas (all use same patterns)
3. Standardized testing (all use same frameworks)
4. Automated deployment (CI/CD working perfectly)

Then: Add agent code generation, validation, deployment.

If You’re Doing Research/Experimentation

Model after: Anthropic (automate experiment running and analysis)

Start with:

1. Automate experiment setup
2. Automate result analysis
3. Automate report generation
4. Automate next experiment suggestion

Key Takeaways

1. Autonomous factories exist and work — Proven at Gitpod, Ona, Anthropic scale
2. Start small, scale incrementally — Don’t boil the ocean
3. Quality gates are non-negotiable — 100% doesn’t compromise for speed
4. Humans become architects — They steer strategy, not implementation
5. Economics are compelling — Same budget, 5-10x output or 80% smaller team

Frequently Asked Questions

Q: Are these systems actually production-ready, or still experimental?
A: Production-ready. Gitpod deployed 688 PRs through this system, with 100% CI green rate. Ona runs it for 50+ engineers across 200+ microservices. These aren’t demos — they’re running production code at scale. Expect 95%+ reliability, not 99.9% (still human-managed for now).

Q: What’s the real success rate of autonomous deploys — do they actually work?
A: 88% full autonomy (zero human intervention) at Gitpod, 60%+ at Ona. Remaining 12-40% need: clarification on requirements (3-5%), human approval for risky changes (2-3%), failure investigation (1-2%). These are not bugs — they’re intentional gates for safety. Systems work; gates exist by design.

Q: How do failures actually get handled in production?
A: Multiple layers: (1) Tests catch most issues before production. (2) Staging deploy validates end-to-end. (3) Canary deploy to 5% traffic first. (4) Monitoring catches metrics anomalies. (5) Auto-rollback on error rate spike or latency threshold. (6) Human on-call investigates. Gitpod has 0.2% bug escape rate — issues caught quickly.

Q: What’s the team structure needed for this level of autonomy?
A: Gitpod: ~15-20 engineers supporting 688 autonomous PRs. That’s 1 engineer per 34-45 PRs (vs. 1 engineer per 2-3 PRs traditionally). Ona: 50 engineers with 200+ services. Key roles: (1) Agent system maintainers (2-3 people), (2) QA for monitoring (2-3), (3) Feature owners (most engineers), (4) On-call for incidents (1 rotating).

Q: How long before autonomy kicks in — can a new company adopt this immediately?
A: No. Foundation required: (1) Automated testing culture (2-4 weeks to establish). (2) CI/CD infrastructure (2-4 weeks). (3) Staging/canary deployment (2-4 weeks). (4) Monitoring and alerting (2-4 weeks). Then agent integration (4-8 weeks). Total: 12-24 weeks from zero to partial autonomy, 6 more months to high autonomy.

Q: What’s the cost per autonomous feature at scale?
A: $20-40 per feature in LLM costs (planning + building + reviewing). Infrastructure: $2,000-5,000/month for agent servers. Total: ~$50-100 per feature including infra. Compare to: 1 developer = $150-200k/year ÷ 1000 features/year = $150-200/feature. Autonomous is 2-4x cheaper.

Q: Can I actually see the code agents generated?
A: Yes, it’s all in git. Pull requests show agent-generated commits, code diffs, and reviewer feedback. Gitpod’s 688 PRs are publicly visible in their repo. You can audit quality, patterns, and decision-making. Transparency is crucial for trust.

Next in the series: Building your first autonomous factory — architecture and setup guide.