Software factory · AI agents · engineers

A team of AI agents builds your software. Our engineers are accountable for it.

Codebrains pairs architects with enterprise project experience with a team of specialised AI agents. Agents write code, tests and documentation in parallel. An architect plans, checks and approves every change.

Start with a pilot See how the factory works
  • 1 architect leads every project
  • agent roles matched to the project
  • 100% of changes reviewed and tested
factory running#428 · export invoices to CSV
LD

Lead

plan + criteria

done
BE

Backend

API + migration

running
FE

Web

export view

running
MO

Mobile

Android + iOS

running
QA

QA

affected tests

waiting
RV

Reviewer

diff review

waiting
PR

Pull request

test evidence

waiting
EN

Engineer

decision: merge

waiting
How the factory works

Every feature goes through the same process.

We proved this process on our own product. Agents speed up the work, while quality gates and human decisions keep the outcome predictable.

  1. 01You + architect

    Request

    You describe the need. We turn it into a task with acceptance criteria.

  2. 02Lead agent

    Plan

    Scope, dependencies, API contract and file ownership for each specialist.

  3. 03Specialist agents

    Build

    Backend, web and mobile work in parallel in isolated copies of the repository.

  4. 04QA agent

    Test

    Tests for the areas the change touched, instead of running everything every time.

  5. 05Reviewer agent

    Review

    Independent review of correctness, security and regressions. Fixes, then another review.

  6. 06Human

    Merge

    A pull request with test evidence. Only what an engineer approves reaches production.

Services

We build your product or set up the factory in your company.

Order finished software from our factory, or adopt the same way of working in your own team.

Core service

Product from the AI factory

A web or mobile application or an internal system, from specification to release. We work in your repository and you see every task and every pull request.

  • MVPs and new modules in existing systems
  • API contracts and database migrations with compatibility tests
  • Android and iOS apps with a backend
  • Architecture documentation updated together with the code
  • You own the code and the whole repository
Get a product quoteScope and cost of the first stage after a needs analysis.

A factory in your company

We configure AI agents in your repository and fit them to your team’s process.

  • Agent instructions, roles and procedures
  • Quality gates and CI checks
  • Task queue in GitHub or Jira

An engineer with an agent team

IT staff augmentation where the expert brings their own team of agents. One person on your team, the throughput of several.

  • Senior + backend, web and QA agents
  • Works in your tools

QA and E2E testing with agents

Agents write and maintain regression tests and end-to-end scenarios for applications nobody tests by hand anymore.

  • Tests of real user journeys
  • Evidence reports for every change

From mockup to code, 1:1

The HTML mockup is the source of truth. Agents build screens and compare style values with the measured view, without guessing from screenshots.

  • Design tokens for web and mobile
  • Shared UI components

Training: coding with agents

Workshops for teams that want to work with AI agents without losing control of quality and security.

  • Hands-on with your code
  • Roles, review, model costs
Factory rules

Agent speed, human accountability.

These rules apply to every factory we run or set up for a client.

merge: human-only

A human approves every merge

Agents never push to main branches. Every pull request goes through review and an engineer’s decision.

owner: 1 per file

One author per file

Work is split so agents running in parallel never overwrite each other’s changes.

secrets: never

Secrets stay out of code and logs

Tokens, personal data and user content never reach the repository, logs or tickets.

checks: affected

Tests where the change is

We run tests for the affected areas. Faster, cheaper and with evidence for every PR.

trail: issue

A full decision trail

Plans, hand-offs between agents and decisions are recorded in the task. You see who changed the code and why.

model: routed

The right model for the task

Simple tasks run on cheaper models. Stronger models only get the work that needs them.

Built in the factory

A mobile app with AI features, developed by two agent stations.

We proved the factory on a production app with a cloud backend and paid AI operations. Two stations, Windows and Mac, take tasks from a shared GitHub queue and review each other’s pull requests.

App
Flutter with native Android (Java) and iOS (Swift)
Backend
Python, PostgreSQL, OpenAPI contract, AWS
Agents
Lead, feature orchestrator, backend, mobile, QA, reviewer
Quality
HTML mockups as the source of truth, E2E tests, review of every PR
mobile app · task queueGitHub Issues

Station A Windows · Android, AWS

Credit limit before a paid operation starts#312merged
File upload in the graphics module#310merged

Station B Mac · iOS, signing

AI image generation backend#284needs-review
Review of station A’s PRread-onlyfindings → PR
  • lead
  • feature-orchestrator
  • backend
  • android
  • qa
  • reviewer
  • owner: merge
  • Angular
  • React
  • TypeScript
  • Java
  • Android
  • Flutter
  • Swift
  • Python
  • PostgreSQL
  • AWS
Engagement models

Start with a small step on your own code.

We price the work after the workshop, once we know the repository and the goal. Every stage ends with a concrete result.

Step 1

Workshop

We review your repository and process, then show the agents working on a real task.

  • Repository readiness assessment
  • Demo on your code
  • Pilot plan

Result: a report and a pilot proposal

Step 2

Pilot

One feature goes through the whole factory process: from task, through agents and tests, to merge.

  • Agents configured in your repository
  • Feature delivered with tests
  • Comparison with your current process

Result: a working feature in production

Step 3

Factory subscription

A steady stream of tasks delivered by our factory, or by your team with our support.

  • Task queue and priorities
  • Review and validation of every change
  • Regular progress and cost report

Result: a predictable delivery pace

Questions

What clients usually ask.

Who is responsible for the quality of code written by agents?

Our engineer. Agents prepare the changes, but the plan, the review and the merge decision belong to a human. Every pull request includes test evidence.

Who owns the repository and the code?

You do. We work in your repository and your cloud accounts. Agent instructions and configuration stay with you when the engagement ends.

Which AI tools do you use?

We work with Claude Code and Codex. We match the model to the task, so you do not pay for a stronger model where a simpler one is enough.

What about data and secrets?

Secrets, tokens and personal data never reach the code, logs or tickets. Agents work on synthetic data unless you explicitly agree otherwise.

Does this work with an existing legacy system?

Yes. We start with a workshop that shows what needs preparing: tests, module documentation and ownership boundaries. Agents also work well for modernisation.

Contact

Tell us what you want to build. We will prepare a plan and a quote.

Describe the product or module you want to deliver with AI agents. We will reply with the scope, timeline and cost of the first stage.

Email
kontakt.codebrains@gmail.com
What are you interested in?

We usually reply within 1 business day.