How We Build Software

Agentic AI Development, Held to One Standard.

How Agentic AI Fits Into How We Work?

Our agentic AI development follows a few core ideas on every project, and they don’t change because an AI agent did the work. Seven AI agents carry a client conversation to tested, merged code, and people review it before it is deployed. Every change is held to the same standard as code a person writes by hand.

Agentic AI works inside the workflow, not beside it

The agents use the same artifacts we use every day: issues, milestones, the board, pull requests, reviews. There is no parallel AI track to reconcile later.

People decide, agents deliver

The approver signs the brief, the spec, and the plan, and a person decides what enters the work queue. A reviewer agent holds the verdict inside the code and review loop, and a person reviews the result before it is deployed.

Everything traces to intent

Every task traces to a feature, an objective, a plan, and the technology architecture behind it, and from there to the signed spec and brief. The architecture comes first, so nothing is planned against an assumption.

One owner per topic

Every rule is written once, in one place, and everything else points to it. How a pull request is opened, what makes a task ready, and how code is named each have exactly one owner.

Contracts, not scripts

Each agent is defined by its purpose, its inputs, its outputs, and the professional it behaves like. Inside that contract it chooses its own approach, and a step-level rule is written only after the same mistake happens twice.

The system learns

Every project feeds back: learnings become improvements to skills, standards, and architecture decisions. The way we build gets sharper with each engagement.

Agentic Workflow From First Conversation to Deployed Code.

Every engagement runs the same path from the first client conversation to code running where the client needs it. AI agents carry out the first five steps, and people own the decisions: the approver signs the brief, the spec, and the plan, and a person reviews the delivered work before it is deployed. The brief and the spec are client documents; the plan, the code, and the review run as tracked work in issues. The approver is the client on most engagements, and A-CX where the client has asked us to run the whole delivery. Deployment sits outside the agent pipeline: once a person has reviewed and accepted the merged work, it goes to each deployment target defined in the plan.

CLIENT DOCUMENTS · Signed by the approver

Brief

deliver-brief, a senior engagement lead, captures the client’s intent from meetings, documents, and public sources into the brief: what we intend to deliver, in language the approver can check and sign. The signed brief is the reference point for everything that follows.

Spec

deliver-spec, a senior product manager with deep engineering understanding, turns the signed brief into testable requirements and acceptance criteria, plus the solution requirements: capabilities, actors, boundaries, integrations, and where the solution runs. The approver signs it before anything is planned.

ISSUES · Engineering

Plan

deliver-plan, a technical program manager who has shipped software, defines the technology architecture first, including how the product is deployed. Then it breaks the spec into objectives, milestones aligned with the SoW, and ready tasks with acceptance criteria and dependencies. The approver signs the plan.

Code

deliver-code, a senior software engineer, implements each task against its acceptance criteria, test-first, on its own branch. Several run in parallel on the same repository without getting in each other’s way.

Review

deliver-pr-review, a principal engineer, reviews each pull request in a separate context from the code, for correctness, security, standards, and naming. It approves and merges, or requests changes and the work goes round again.

Two more agents run this loop. deliver-unit, a tech lead who drives work to done, takes a task or a feature through code and review until it is merged, verifies it is finished, and leaves nothing open behind it. deliver-autonomous, a dispatcher on a night shift, works a queue of ready tasks through deliver-unit with no one present, and stops only for a decision that belongs to a person.

People decide, AI delivers. Nothing is specified, planned, queued, or deployed without a person’s approval, and silence never counts as approval. Every commit, review, and merge carries the identity of the operator who started the run: one of our people, or one of our named AI personas, such as Graig and Taina, each with its own accounts and permissions.

Everything Traces Back

Deployed code

Merged code

Task

Feature

Objective

Plan

Architecture

Spec

Brief

Every constraint from the architecture is carried into the plan and the task’s acceptance criteria, so the agent writing the code works from the task and its plan, and every line of code traces to a reason for existing.

Industry-Leading AI, Our Standards on Top.

Frontier AI Models

Claude and OpenAI, in parallel

Our AI workflow uses both Anthropic’s Claude and OpenAI’s models together, among the most capable AI coding models available, run in parallel on the same task alongside the same git, build, and review tooling our engineers use every day.

The A-CX Layer

Integrated into Codex and Claude

On top of both sits our own layer: seven delivery agents, the skills behind them, and our quality rules, installed directly into the Codex CLI and Claude desktop and CLI. We distribute and update it through our plugin marketplace, so every engineer and every AI persona works with the latest A-CX standards.

The Right Model for the Right Task, at the Right Cost.

Every agent declares the AI model and effort level its work needs and runs on it, so routine work runs light while planning, architecture, and security judgment stay on the strongest model. The result is sound engineering decisions without wasted effort.

Fast

Lightweight tasks

Background work, monitoring, simple transforms, and pattern detection. Quick, low-cost, high-volume.

Balanced

Everyday delivery

Code review, security review, implementation, and standard development tasks.

Reasoning

High-judgment work

Architecture, planning, requirements analysis, and security judgment, where getting it right matters most.

When the output isn’t good enough, the task moves to a stronger model, and the run says so. Long work that needs only a lighter model runs as its own subagent, so the cost drops and the quality does not. A bad decision early costs far more than the difference in compute.

Quality is Enforced, Not Requested.

Our quality standards run automatically inside delivery, never a checklist someone might skip. Exceptions are explicit, documented decisions, never quiet omission

Test-first

New code is written against tests first. Behavior is specified before it’s built, not validated after.

Security Review

Security is reviewed as its own dimension, in its own context, on every delivery: designed in, not bolted on afterward.

Independent Review

Code and review never share a context. Every change is checked against the coding standards and naming rules set in the plan, with automated checks green, before it merges.

Clean History

Conventional commits, one branch per unit of work, and nothing left open when the work is done keep the codebase auditable and easy to hand over.

Discuss Your Project

Great things happen when good people connect. Leave us your details, and we’ll get back to you.

By sending the information in this form, you agree to have your personal data processed according to A-CX’s Privacy Policy and Cookie Policy to handle the request and respond to it.