Building an Agentic-First ERP from Scratch — The Triox Story

This one started as a note to myself. For roughly six months I turned the same idea over in my head: our manufacturing workflow was becoming too complex to run on memory, spreadsheets, and a busy WhatsApp group — and the honest fix was not to hire our way out of it, but to build the system we actually needed. We do not have robots. We are not at that scale yet. We build about 300 vehicles a year. But that is exactly why the timing felt right. Automation is easiest to install before the chaos hardens into habit, not after. So instead of buying an ERP that assumes a factory we are not, we built one from scratch — with an agentic-first approach and frontier AI models doing the heavy lifting.

Why now, at 300 vehicles a year

There is a comfortable myth in manufacturing that automation is a big-company problem — something you tackle once you are running thousands of units and can justify robotics and a software team. In practice, the opposite is true. At low volume, every process still lives in someone's head, every exception is handled by a human favour, and every handoff is a verbal one. That works until it doesn't. The moment you double output, all of that informal glue tears. We decided to build the system while the workflow was still small enough to model faithfully — so the software encodes how we actually work, not a vendor's guess at how a generic factory works.

Agentic-first, not AI-as-a-feature

Most software bolts a chatbot onto a form-heavy application and calls it AI. We inverted that. We designed the ERP around agents from the first sketch — goal-directed assistants with real tools that can query products, quotations, work orders, inventory, and vendors; draft documents; and render interactive UI inside a conversation. Frontier models did two jobs for us. First, they were the co-builder: we used them to reason through data models, generate the platform, and iterate far faster than a traditional build. Second, they became the runtime: the same agent architecture we admire in vehicle autonomy — specialised tools, structured memory, deterministic routing for the flows that must never improvise — now runs inside our operations.

• Agents operate the system, not just talk about it — creating quotations, checking work-order status, triggering vendor documents.
• Every privileged capability is a server-side tool with its own guardrails, never a raw prompt with keys attached.
• Critical workflows (pricing, work orders, customer records) use deterministic routing so the agent follows a fixed path, not a creative one.
• The agent has structured memory of the thread, so a multi-step task survives interruptions.

What we actually built

The result is a single unified platform that functions as ERP, PLM, CRM, and manufacturing execution system — one database, one auth model, one audit trail. Everything a vehicle passes through on its way from an enquiry to a delivered product lives in the same place, linked.

The benefits, in plain numbers

The payoff is not "AI magic." It is the boring, compounding value of a single source of truth with intelligence layered on top. Because BOMs, purchase orders, and work orders reference the same data, the errors that used to leak between systems simply have nowhere to hide.

Security we designed in, not bolted on

An operations platform holds the most sensitive things a company has — customer data, pricing, supplier terms, payments, and staff information. Because AI agents can act inside this system, security could not be an afterthought. It is the substrate.

• Row Level Security on every table — no table ships without a policy. Data is gated by role, so a query can only ever return what the caller is allowed to see.
• Privileged operations run in server-side edge functions with the service-role key. That key is never bundled into the browser; the frontend only ever holds the anonymous, RLS-gated key.
• Secrets live in environment configuration and encrypted secret stores — never in code, never printed in full, never committed.
• Payments use a hosted checkout flow; we never store card data, and every payment webhook signature is verified before we act on it.
• Consented, minimal PII: sensitive fields like staff location are captured only after explicit in-app consent, stored as last-known-only, and readable strictly by a single privileged role — never exposed to the general application.
• Agents inherit these boundaries. An agent can only reach what its authenticated user can reach; it cannot escalate its own privileges.

Governance: documentation, approvals, and human judgement

Automation without governance is just a faster way to make mistakes. The part I am most proud of is not the speed — it is that the system is disciplined. Three things keep it honest: everything is documented, important actions require approval, and a human always holds the final judgement.

Documentation — nothing happens off the record

• Every meaningful change to an entity is written to an audit trail — who changed what, and when — visible on the record itself.
• PLM enforces revision control: manufacturing cannot build against a draft. The document on the shop floor is always the one engineering formally released.
• The build process itself is documented and versioned, so we can always answer "why does the system do this?" by pointing at a decision, not a memory.

Approvals — consequential actions are gated

• Engineering revisions are approved before release; the approval, not the upload, is what makes a drawing usable downstream.
• When an AI agent proposes a destructive or privileged action, it must present a clear Confirm / Cancel to a human before anything is executed.
• Production changes ship behind a manual approval gate. There is no path where an automated process pushes to production without a person saying yes.

Human judgement — the agent proposes, the human decides

We treat data from the system as data, never as commands — a support ticket that contains "instructions" does not get to instruct the agent. The AI drafts, correlates, surfaces, and recommends. It does not get the last word on anything that matters. When something goes wrong, the question we ask is "why did the system allow this?" — not "who do we blame?" That keeps the culture blameless and the systems accountable, which is the only combination that actually improves over time.

“We do not automate to remove people from the loop. We automate to remove the noise, so the people in the loop are deciding the things only humans should decide.”

— Deepak Mohan, Triox Mobility

AlterAI.OS — the engine that made this possible

None of this would have been buildable, at our size, in this timeframe, without the engine underneath it. AlterAI.OS is the proprietary agentic platform we built on — the layer that turns frontier AI models from a clever assistant into a disciplined system-builder. It is what let a manufacturing company, not a software house, stand up a production-grade ERP.

• An agentic build loop that reasons about the domain, generates the platform, reviews its own work, and learns from every session — so the system compounds knowledge instead of forgetting it.
• Guardrails as first-class citizens: security policies, approvals, and audit trails are part of how it builds, not chores added later.
• A knowledge and governance spine — documented decisions, encoded conventions, and human checkpoints — so the software stays explainable as it grows.
• The same agent runtime in the product: server-side tools, structured memory, and deterministic routing for the flows that must be exact.

Where this goes next

What we have today is the foundation, not the finish line. Because the data is unified and the agents are already inside the workflow, the future possibilities are less about new modules and more about intelligence deepening across the ones we have.

1. Circular data: field performance and telemetry flowing back to engineering, so every vehicle generation inherits the lessons of the last.
2. Predictive operations: agents that forecast material shortages, quality drift, and delivery risk before they become problems.
3. Supplier and quality intelligence: continuous scoring of vendors and components from live PDI and field data.
4. A path to the shop floor: as volume grows, the same platform is ready to connect to machines and, eventually, robotics — the workflow brain is already built.
5. Portable by design: because AlterAI.OS is the engine, the playbook we proved on vehicles can run any complex manufacturing operation.

We set out to automate a complex manufacturing workflow at a scale where most people would say it is too early to bother. Six months of thinking and an agentic-first build later, I am convinced it was exactly the right time. Build the discipline while you are small, and scale stops being scary.