Between July 1 and July 6, 2026, one engineer and a fleet of AI agents built a working agentic ERP core on the Angee framework: order-to-cash, procure-to-pay, inventory, and a CRM pipeline, with multi-company permissions and audit built in. 87 commits. 298 automated tests. Eight review-gated slices. The engineer didn't write the code — the agents did. And the build got faster as it went: the last four business domains shipped in a single day.

Every number in this post comes straight from the repo's git history and can be checked against the source. That's the point of building in public.

What got built

ARPEE is a set of addons that implement an agentic, self-improving ERP on top of the Angee framework. By the evening of July 6 the core covered the flows a real business runs on: quotation → order → invoice → payment; RFQ → purchase order → receipt → vendor bill; warehouses, stock, and deliveries; a CRM pipeline that converts leads into quotations. Ten business addons, all company-scoped, all permission-gated, with chat, calendar, and ratings composed onto every document. Not a demo of one happy path — a multi-company core where user bob provably sees zero rows of company A's data.

How agents build: work orders, review gates, live acceptance

The engineer's role was direction and review, not typing. Each slice of the build followed the same loop:

A spec becomes an executable work order. Every slice starts as a written plan with numbered decisions — reviewed and revised before any code exists. The slice-1 plan was "reconciled through three review passes" before the first feature commit landed.
Agents write the code. Framework addons, Django models, permission schemas, React surfaces, tests, demo data — authored by agents against the work order.
Independent review rounds. Separate reviewers (agents again, including a second model) audit architecture, backend, and frontend; the git log is full of commits like "review round — locked qualify, real concurrency proofs." Findings get fixed or explicitly deferred — never silently dropped.
Live acceptance in a real browser. Agents drive the actual UI as persona users and screenshot the results — including the cross-company isolation checks. The program stops for a human review gate; it doesn't proceed on vibes.

That loop ran eight times in a row. Here's what the clock said.

It accelerated

Three quiet days of planning followed the July 1 scaffold. Then the first executable work order landed on the evening of July 4, and the sprint from there to "wave 3 complete" took about 48 hours. Timestamps from git, spec-commit to closure-commit:

Slice	Domain	Elapsed
1	Products, sales, invoicing & payments (+ money, sequences, units incubated)	~10.5 h
2	Variants, pricelists, analytic accounting, tags	~5.5 h
3	Chatter on every business document	~2.5 h
4	Calendar, scheduling, CSAT ratings	~5.5 h
5	Team chat — rooms & DMs	~3 h
6	Inventory & warehouses	~6.5 h
7	Purchase — procure-to-pay	~4 h
8	CRM pipeline	~4 h

The first slice — three business addons plus three framework foundations — took a night. By the final day, domains of comparable weight were closing in four hours each, review rounds and live acceptance included: July 5 closed four slices, and July 6 closed four more — team chat, inventory, purchasing, and CRM, between half past midnight and half past eight in the evening.

The acceleration isn't magic; it's compounding. Slice 1 had to incubate currencies, document numbering, and units of measure before it could sell anything. Every slice after that inherited them. Tags arrived in slice 2, recurrence rules in slice 4 — and each was promoted into the framework, so the next domain started further up the hill. By slice 7 the test suites had been migrated onto one shared harness; by the calendar rework, an entire page had collapsed into a declaration riding the framework's view family. After the wave closed, a follow-up refactor moved another set of tests down into the framework — the ERP's suite shrank because the platform underneath it grew.

That's what we mean when we say ARPEE is self-improving: the agents aren't just building an ERP, they're hardening the substrate that makes the next module cheaper than the last.

ERP → ARP: velocity is the point

Every ERP ever built assumes the worker is human. Agentic Resource Planning (ARP) assumes some of your team are not — and gives them identities, scoped permissions, and an audit trail instead of a shared API key.

This build is the argument in miniature. An agentic ERP shouldn't just have agents in it; it should be the kind of system agents can extend safely — specs in, reviewed code out, permissions enforced by construction. If agents can build the ERP in days, they can build your missing module in days too. The velocity is the demo.

What this isn't (yet)

Honesty section. ARPEE is early alpha. Manufacturing, HR, projects, point-of-sale, eCommerce, and BI exist as specs, not code. There's no PDF reporting, no statutory localizations, no production deployments — today it runs as a seeded demo stack. The six days bought a core, not a finished product.

But the core is real, the process is repeatable, and the pace is compounding. If you want to watch the remaining waves get built — or get early access when self-host and hosted previews open up — join the ARPEE alpha waitlist, or read the code the agents wrote.

Drafted by an Angee agent, reviewed by a human.

— The Angee team