The Product — Early access

ARCfactory

Architect / Rule / Create

Our AI-native software factory. It changes how software is specified, built, tested and delivered — agents doing the work, engineering governance holding the line. Where we are heading, it also changes how you pay: per usage or per outcome, not per hour.

Request early access How it works

§ 01The name01 / 07

Architect.
Rule. Create.

ARC is the order the work happens in, and the reason the output holds. Design the solution first, decide who controls what, then build it with everything pointed at that design. Skip the first and agents produce something confident and wrong; skip the second and nobody can say who signed it.

The point is set, and the line to it

Architect

Design the solution before anything is built. Twenty years of delivery goes in here — what the system has to do, how it fits the estate around it, where it will be put under load, and what would make it wrong. This is the part agents cannot originate, and the part that decides everything after it.

A limit across the ground, one gate

Rule

Set the governance the build runs under: what agents may touch, which decisions need a signature, what gets logged, and how a bad change is rolled back. Control sits where the project needs it — direct human, agentic, or hybrid — and is chosen deliberately rather than inherited by accident.

Everything runs through the gate

Create

Put the resources in and build what was architected, under the rules that were set. Requests, context, specifications and agents all point at one design, so throughput scales without the result drifting from the thing that was agreed.

The five-step production line below is how those three are actually run: architecture becomes intent and specification, the rules become the gate, and creation is the part agents do at volume.

§ 02The idea02 / 07

Software is specified
more than it is typed.

Most delivery time is not spent writing code. It goes into deciding what should exist, keeping that decision consistent as it moves through a team, and proving it still holds once it reaches production. Agents changed the cost of typing. They did not change the cost of deciding — so ARC industrialises the part that actually takes the time.

The specification is the artifact

Prompts are not a deliverable. A specification can be reviewed, versioned, argued with and tested against — so that is what ARC produces first.

Agents do not merge their own work

Throughput comes from agents. Authority does not. Every release passes a human gate, and a named engineer is answerable for what shipped.

Governance is built in, not bolted on

Permissions, audit trails, evaluation harnesses and rollback paths are part of the production line rather than a compliance exercise afterwards.

It runs on our own work first

ARC builds East Wolf projects every day. We meet its failure modes before a customer does.

Integration is the hard part

Generating code is the easy half. Making it fit an estate that already exists — data, rules, approvals, deployment — is where the engineering lives.

Small batches, on purpose

Early access is deliberately narrow so each team gets a senior engineer watching how ARC behaves on their real work.

§ 03The production line03 / 07

How ARC
works.

Agentic development is not a chat window. It is a production line with checkpoints, and humans appear exactly where judgment is required: at the start, when intent is set, and at the gate, before anything ships.

01Human

Intent

You describe what the software should do — in plain language, a document, or a call. No tickets, no spec template to fill in.

AArchitect

02Agents

Specification

Intent is compiled into something testable: requirements, interfaces, architecture and acceptance criteria you can argue with before a line is written.

AArchitect

03Agents

Production

Agents build, test and review against that specification, iterating until every acceptance criterion passes.

CCreate

04Hybrid

Verification

Checks run at the gate — by an engineer, by agents, or by both, depending on what the project demands. What does not vary is the signature: a named senior engineer is accountable for what ships.

RRule

05Agents

Ship and run

It deploys, and ARC keeps it alive — patched, monitored, and evolving as the intent changes.

CCreate

Intent is always human and production is always agentic. Verification sits between them — engineer, agents, or both, decided per project. That the gate exists at all is the product; it is what separates a factory from a code generator.

§ 04Standards04 / 07

Built to the standards
you answer to.

An agentic build is only usable inside a real company if it can survive the same scrutiny everything else does. These six are what ARC is engineered against — they shape the gates, the logging, the access model and what an agent is allowed to touch.

SOC 2

Service controls

Security, availability and confidentiality controls around the systems ARC runs on, evidenced rather than asserted.

GDPR

Data protection

Lawful basis, minimisation and deletion designed into what agents may read and retain — not a policy bolted on afterwards.

EU AI Act

AI regulation

Risk classification, transparency about where agents act, and the human oversight the regulation expects at the gate.

ISO 9001

Quality management

The production line is a defined, repeatable process with records — which is what makes an agentic build auditable at all.

ISO 27001

Information security

Access control, secrets handling and audit trails across every step an agent can reach.

ISO 42001

AI management systems

The newest of the six, and the one written for exactly this: managing AI systems responsibly across their lifecycle.

These describe how ARC is built and the controls it ships with. Where a standard requires independent certification, that is stated per engagement rather than claimed here.

§ 05Horizon05 / 07

Today it builds our work.
Then it builds yours.

ARC is one product inside East Wolf, not the company. It earns its way outward: our delivery first, then a small batch of teams, then anyone who wants to run the same operating model.

Today

ARC powers our own delivery. Every project we ship runs through it.

A small batch of teams gets access, with governance included and an engineer alongside.

Then

Organizations build software themselves, on the same operating model, and pay per usage or per outcome.

§ 06The model06 / 07

Pay per usage or per outcome.
Not per hour.

This is the business model we are building ARC toward: we charge only per usage or per outcome. Once agents do the production work, hours stop being the real cost of software, so they should stop being what you pay for. That could make projects a lot cheaper, and give you far more for what you spend than the models it replaces.

What we are building toward

Per usage

You pay for what you run.

You pay for what you actually run through ARC, as you run it. Use less and you pay less, with no team held on standing cost.

Per outcome

You pay for an agreed result.

You pay for a result that was agreed up front and delivered. ARC writes the acceptance criteria before it builds, so the result can be checked rather than argued about.

What it replaces

Time and materials

You pay for hours, whether or not they produced anything you can use. With agents doing the production work, hours are the wrong thing to meter.

Fixed cost

You pay for a scope agreed up front, with the risk priced in. When the scope moves, and it does, you pay again to change it.

Procurement

You pay for the process as well as the work: tenders, long contracts and months of cost on both sides before anything is built.

This is a direction, not today's price list. Work we take on now still runs on our current engagement models, and the rates and terms for per usage and per outcome are not set yet.

See current pricing

§ 07Early access07 / 07

We are opening it to
a tiny batch.

Not a public beta, and not a waitlist we forget about. We take on a handful of teams at a time, because each one gets a senior engineer watching how ARC behaves on their real work — and that attention does not scale to a large cohort.

What you get in the batch

Access to ARC on one real project of yours.

A senior engineer alongside you for the whole run.

The governance layer — gates, audit trail, rollback.

Direct influence on what we build next.

If the fit is not right yet we will say so, rather than park you in a queue indefinitely.

Request early access

We open ARC to a small batch at a time. Tell us what you would build and we will come back to you directly.