Operator
Runs the agent pipeline and takes on the hard technical problems: edge cases, integrations, and security. Gives final approval on every architecture decision.
A structured, AI-enabled delivery system we build and run for you. A fleet of AI agents writes, reviews, tests, and ships software, under the direction of a senior engineer, a product owner, and you.
The Software Factory is a delivery system we build and run for you. It takes a written specification and produces working, production-ready software: new products, features or modules added to an existing codebase, prototypes hardened to production quality, platform migrations and compliance rewrites, and integrations that span several systems. It is also how we estimate level of effort and find the roadblocks in a large initiative before it starts.
It is more than a reference setup. It is designed to overcome the weaknesses of unsupervised AI development — bias, blind spots, hallucinated architecture, and suspect foundational decisions — by keeping experienced people in control of what gets built and how. Every engagement is led by a senior engineer and a product owner, so the speed of AI never runs ahead of the judgment that keeps the work sound.
Every engagement is staffed with at least two of our senior people. They are named, and they are accountable for what the Factory ships.
Runs the agent pipeline and takes on the hard technical problems: edge cases, integrations, and security. Gives final approval on every architecture decision.
Turns your priorities into scoped work, runs independent verification and testing, manages the trade-offs, and is your primary point of contact.
Scope, complexity, and support needs can call for more people. Two is the floor, not the target.
The Factory coordinates a fleet of AI agents in two layers. An orchestrator reads each task, decides which specialist should handle it, and assembles the results. Each specialist does one kind of work, with access only to the tools that work requires.
Writes the core product logic.
Builds the client-facing interface.
Writes automated tests alongside the code.
Checks code for bugs and standards.
Approves or blocks structural decisions.
Handles work that spans several areas.
Reviewers and architects cannot change code, so no agent approves its own work.
Only the orchestrator assigns work, which keeps the fleet from looping.
Specialists run in parallel, so multiple workstreams move at once.
For load-bearing decisions — architecture, security-sensitive choices, scope, a dependency, a public interface — no single agent decides alone. A position is put forward, a critic built on a different AI provider family attacks it, the original agent rebuts, and a person arbitrates the result before it is locked.
No single agent locks in a load-bearing decision.
Model families share training data and benchmark exposure, so they tend to make correlated mistakes and sample the same blind spots. A second opinion from the same family is not a second prior. Making provider diversity structural means the reviewer most likely to catch a confidently wrong answer is the one least likely to share its author’s blind spot.
The fleet draws on Claude (Anthropic), GPT (OpenAI), Qwen (Alibaba), and DeepSeek, among others. Different providers take different roles — orchestration, bulk execution, and independent critique — so no single vendor’s blind spots decide your delivery.
It also means the execution and critique work is not dependent on any one provider: if a provider has an outage or changes its pricing, that work routes around it automatically. The orchestrator is the deliberate exception — it stays on Anthropic for its long-horizon context management.
Two real engagements. We took out the client names and nothing else.
A financial-analytics platform serving portfolio values, returns, and holdings over an API, on three data stores with three different consistency models, still carrying client-visible drift from an old migration.
The hard part of production is not writing code. It is understanding a system you didn't build, changing it safely, and proving you didn't break it.
An internal operations app — workforce planning, time-tracking, role-gated finance views — generated with AI on a hosted Postgres database, taken to secure, compliant, production-grade software.
Prototype builders will get you a working app in a weekend. The part that decides whether a product survives real users is the part they do not do.
Every engagement produces working software committed to your repositories, along with the evidence that it meets what was agreed. What we have built this way includes multi-tenant SaaS platforms with role-based access control, care-planning and case-management workflows, real-time messaging, billing integrations, REST and GraphQL APIs, authentication and authorization systems, and data import and export pipelines.
Full-stack software on React and Next.js, with Node.js or Python behind it and TypeScript throughout, built in numbered, testable iterations. Every contract item is mapped to the iteration that delivered it, in a scope coverage report.
Build, test, and deploy pipelines, hosting and environment configuration, database provisioning, and monitoring, all documented in a runbook.
Dependency scanning and code-level review on every iteration, with security-sensitive code checked by a reviewer from a different model family than the one that wrote it.
Unit, integration, and end-to-end tests written alongside the code and run on every commit. Nothing is marked delivered until they pass.
A structured archive that documents what was built and proves it meets the agreed scope: technical deliverables, quality evidence, a decision log, and the runbook.
The Factory works on code it did not write.
On an existing codebase there is a ramp-up period before any shipping begins, while the team maps what is already there: the product, the features, the architecture, the conventions, and the known issues. That work is not something you pay for twice. The decision log from the ramp-up becomes part of the permanent record for your engagement, so what we learned about your system stays with you.
You talk to the Factory in a dedicated Slack channel. There is no portal, no ticketing system, and no standups to attend.
You send a request in plain language: a new feature, a bug, a change to how something behaves.
A bot watches the channel continuously and picks it up, including replies on older threads.
The request becomes a tracked item, and you are notified on every update.
The Factory works it and replies with status, output, and any questions that need your input.
Working software lands in your repository when the item is done, with a note on what changed.
One request is handled at a time, and it is only marked done once the work has actually succeeded. If something goes wrong the request stays on the list and is retried. Nothing is silently dropped.
The Factory comes to you only for the decisions that need your judgment: product trade-offs, design choices, priority calls, and gate approvals. Everything else is handled without you.
Your code and your data stay under controls set before any work begins.
Each engagement runs in its own isolated environment on Ballast Lane infrastructure, never a shared public cloud, with client credentials kept separate.
AI workers get only short-lived, task-scoped access. There are no standing connections into your systems.
Model usage runs under API terms that do not use your inputs or outputs for training. Where a provider does not meet that bar, we exclude it if your security policy requires.
Every model call passes through a single recorded layer, so we can show you exactly which model touched your data, when, and what changed.
For sensitive engagements, key data handling can run on self-hosted models on Ballast Lane hardware, so your code and data never leave.
The full data posture is set per engagement and governed by contract before work starts.
Everything the engagement produces is yours, in formats you can read without us.
All code in your repositories, along with the verification packet, the runbook, and the decision log.
No key-person dependency on Ballast Lane staff. Any competent engineering team can pick up the codebase from the documentation delivered with it.
Where you start depends on what you have today. You can pick one entry point or move from one to the next.
One delivery cycle, led by us, on a real product of yours, taken to a real, evidenced outcome. The lowest-risk way to watch the Factory work: you finish with working software and a verification packet in hand, not a pitch.
We run as your delivery engine. You set direction and priorities; the Factory plans, builds, tests, secures, and ships against your roadmap, with senior judgment on every architectural call and a verification packet behind every release.
We embed AI-enabled product owners, designers, and engineers directly into your teams, where they ship real work and transfer the practice by example. Your people learn by building alongside someone who already does it well, and the capability stays after we leave.
We set up a factory tuned to your stack and standards, transfer the operating model to your people, and hand you the keys. You get the blueprint and the hard-won lessons instead of paying to rediscover them.
The full capability overview, and the two engagements above written up in full. No form, no email capture.