How to Set Up a GPT-6 Astra Software Factory

How do you set up a GPT-6 Astra software factory?

To set up a GPT-6 Astra software factory, build seven infrastructure stations around the model first (sandboxing, credentials, PR orchestration, and verification chief among them), then route only the highest-leverage decisions to Astra itself while cheaper models handle implementation. The model isn't the bottleneck anymore. The plumbing is.

What is a software factory, and why does GPT-6 Astra change the math?

A software factory is a development pipeline where AI agents implement changes, run checks, and test the result in isolated environments, while people direct the work and review it through pull requests. Tasks go in. Software comes out, with proof attached that it works. Ramp, Uber, and independent builders like FactoryKit and Port all describe the same shape, regardless of which model sits at the center.

What kept this from working for small teams was never the pipeline design. It was that prior models drifted. They'd start a long agentic run on the right task and wander off it, or quietly reinterpret scope halfway through a multi-hour job. That drift is why most unattended pipelines needed a human checking in every few steps.

GPT-6 Astra's advance is specific: it stays on task. OpenAI's own Terminal-Bench 4.0 results put Astra at 57.9%, against 37.3% for GPT-5.6 Sol and 55.8% for Claude Fable 5.1, at a lower estimated cost per task than either. Independent tester Cole Medin, who handed his own factory to Astra, reported the same thing from the outside: the practical gain wasn't raw intelligence, it was that Astra "stays on task" through long runs without drifting, which had been the main failure mode limiting unattended coding pipelines. CodeRabbit's independent code-review evaluation adds a third, separate line of evidence: Astra catches about 4% more labeled bugs than Sol and 22% more than Claude Opus 5 overall, with the gap widening to 20% over Sol and 33% over Opus 5 on the harder cross-file reviews a factory's merge gate actually depends on. Three independent sources, three different tests, one conclusion: Astra follows intent further than its predecessors did, which is exactly the property an unattended pipeline needs from its planner and reviewer.

Why does owning beat renting, and what sprawl does a factory replace?

The economic case for building instead of subscribing was already strong before Astra. The average company now runs 118 SaaS applications, up from 106 the year before, and 53% of all SaaS licenses go unused in an average 30-day period. Per-employee SaaS spend averages $4,830 a year, and unused licenses alone amount to roughly $21 million in wasted spend annually across large portfolios. A factory that turns internal requests into owned tools instead of new subscriptions is aimed squarely at that waste, the same argument this publication has made about the shift from renting SaaS to owning software in why building beats buying SaaS in 2026.

Which seven stations should you build before you touch a model?

The model choice matters less than most people assume. What actually took one team two engineers and 23 days to build was the infrastructure around the model, producing 403 commits, 95 of them written by the factory itself, with 69 of the first 99 merged pull requests coming from the factory rather than a human. The stations are consistent across every serious build:

• Isolated execution. Every agent run happens in its own sandbox, so a bad command can't touch production or another job in flight.
• Snapshot templates. A pre-baked environment image with dependencies installed, so each run starts fast instead of re-provisioning from scratch.
• Credential brokering. Agents get scoped, short-lived access to the repos and services they need, never a standing key with broad permissions.
• Git and PR orchestration. The factory opens branches, commits, and pull requests on its own, following your team's existing review conventions.
• A server-owned run loop. A scheduler or trigger that kicks off work without a person starting each job by hand.
• Live observability. Logs and traces you can actually read while a run is in progress, not just after it fails.
• Verification. Proof, attached to the pull request, that the change works.

These stations are largely inheritable from an open-source base or a packaged platform. The work specific to your team is the integration and the ongoing maintenance. Some teams assemble this themselves; others start from packaged platforms that already cover the sandboxing, credential brokering, and PR orchestration layers, which shortens the path to the parts that are actually specific to your codebase.

How do you route work between Astra and cheaper models?

Running every step of a pipeline through a frontier model isn't just unnecessary, it's expensive. Astra's standard API pricing is $10 per million input tokens and $50 per million output tokens, roughly 2.5 times GPT-5.6 Sol's rate at fixed usage. The pattern independent builders converged on is a routing split, not a single model doing everything:

1. Cheap, fast models handle mechanical implementation. Writing boilerplate, running the test suite, fixing lint errors: work with a clear, narrow spec doesn't need frontier reasoning.
2. Astra handles planning. Turning a PRD or issue into a concrete, ordered set of tasks is a judgment call, and it's where drift used to start.
3. Astra decides what not to build. Cole Medin's factory splits work so cheap models handle the mechanical parts and Astra handles the highest-leverage parts, including deciding what shouldn't be built in the first place.
4. Astra reviews the hard cases. Cross-file changes and anything touching more than one service go through Astra as reviewer, where its bug-catch advantage is largest.

This is the same trade-off covered in our comparison of Astra and Fable 5.1 for internal tools: the frontier model earns its cost on judgment, not on typing.

How do you wire up verification so unattended merges are trustworthy?

This is the station every team underestimates, and the one that decides whether the rest is worth having. A pull request that passes unit tests can still be wrong in ways a human would catch in ten seconds of clicking around the app. The fix is real-browser regression testing, with a recorded session attached to the pull request as evidence, before anything merges unattended. Uber's inner-loop validation follows the same logic at much larger scale, and it's what has let more than 70% of the company's pull requests now come from local or cloud agents without eroding trust in what gets merged.

How do you run it 24/7 with scheduling, governance, and checkpoints?

Once sandboxing, routing, and verification are in place, the run loop itself is simple: a scheduler or webhook trigger starts work, the factory implements and tests it, and a merge gate decides what goes live without waiting on a person. Cole Medin's version runs with zero human in the loop for the mechanical steps: a PRD or issue goes in, and validated, shipped code comes out the other side, with an explicit MISSION.md list of what should never be built acting as the main defense against scope drift. At enterprise scale, Uber runs the same idea through central governance: every agent tool call passes through a single MCP gateway, which cut fleet-wide token usage by more than 40% while exposing over 1,000 tools, and every model call goes through an LLM gateway handling more than 100 million requests a day. The scale differs by orders of magnitude, but the operating model, a scheduled loop with a merge gate and a governance layer watching it, is the same at either size.

What does it actually cost to build and run one?

For a small team, the reference numbers are concrete: about 1.5 engineer-months to stand up the seven stations, 403 commits over 23 days, with the factory writing roughly a quarter of them itself. At the other end of the scale, Ramp's internal background agent Inspect now produces more than half of Ramp's merged pull requests, up from about 30% earlier in the year, and Uber's Minion platform ships roughly 1,800 code changes a week with 95% of engineers using it. The build reported in our practitioner's guide to building internal tools with AI shows the same shape at founder scale. But maintenance doesn't disappear once the factory is running. One documented small-scale build that replaced $1,003 a month of SaaS subscriptions with five self-built agents found real savings, with the caveat that ongoing agent maintenance consumes roughly 15 to 25% of the time the agents save, a pattern also described in what a 20-hour unattended agent run actually taught one team. Budget for that line item, not just the build.

How do you keep a self-built factory accountable?

A factory that runs 24/7 with credentials to your repos and services is exactly the kind of non-human identity that governance teams worry about. 82% of enterprises already report unknown or unsanctioned AI agents running in their infrastructure, and 65% have had an AI-agent-related incident in the past 12 months. An ungoverned array of agent-built internal tools can quietly recreate the same sprawl problem SaaS caused in the first place, just with your own agents as the vendor. The fix is the same discipline Uber applies at scale: route every credential and tool call through a broker instead of handing agents standing access, keep an audit trail of what merged and why, and review the factory's output the way you'd review a new hire's first quarter of commits, not a rubber stamp.

When should you buy instead of build?

Building your own factory is the right call when your environment has constraints a generic tool can't accommodate, when someone is willing to own the maintenance line item long-term, or when the internal tools you'd replace are specific enough to your workflow that no vendor will ever build them well. It's the wrong call when none of those are true. If your engineering org doesn't have a platform team funded to maintain sandboxing and credential brokering indefinitely, or if the tools you need are generic enough that someone has already packaged the seven stations as a product, buying that packaging and pointing it at your repos is the more honest move. The point isn't to build for its own sake. It's to own the software that's specific to you, and rent the plumbing that isn't.