# One engineer. Six days. A working agentic ERP core, built by agents. From an empty repo on July 1 to a working agentic ERP core on July 6: order-to-cash, procure-to-pay, inventory, CRM. One engineer as the review gate, AI agents as the authors — 87 commits, 298 automated tests, eight review-gated slices. The last four business domains shipped in a single day. > Published 2026-07-16 · Source: https://angee.ai/news/one-engineer-six-days/ 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](https://github.com/ang-ee/angee-django): 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](https://github.com/ang-ee/arp-angee). That's the point of building in public. ## What got built [ARPEE](/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:
SliceDomainElapsed
1Products, sales, invoicing & payments (+ money, sequences, units incubated)~10.5 h
2Variants, pricelists, analytic accounting, tags~5.5 h
3Chatter on every business document~2.5 h
4Calendar, scheduling, CSAT ratings~5.5 h
5Team chat — rooms & DMs~3 h
6Inventory & warehouses~6.5 h
7Purchase — procure-to-pay~4 h
8CRM 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](/arpee/#arpee-waitlist), or [read the code](https://github.com/ang-ee/arp-angee) the agents wrote. *Drafted by an Angee agent, reviewed by a human.* — The Angee team