Resource hub

Why AI agents need a system of record

An agent that acts without an authoritative record produces work nobody can verify. Why the record, not the model, is what makes autonomy safe.

Autonomy is a setting, not a commitment

Adopting agents does not mean handing over control. How observe, propose, confirm and act-within-policy modes let teams widen autonomy at their own pace.

One app, every platform: what WAID changes

Write one Vite and React app, ship a real static website plus native desktop, iOS and Android builds. How WAID ends the native-versus-web rewrite.

Governed autonomy: an architecture for agents that act on enterprise records

A reference architecture for letting AI agents perform real operational work through scoped authorization, a shared record and an append-only audit trail.

From order to books: reconciling evidence across procurement, warehouse and finance

How connected systems of record for procurement, warehousing and finance let agents reconcile ordered, received and billed before an invoice is trusted.

Keep purchase orders moving without rubber-stamping them

Routine orders advance on their own; only the ones that need judgment reach a person.

Reconcile what arrived against what was ordered

Receipts and disputes get recorded against the order as deliveries land, not days later.

Match purchase invoices to their orders before they are paid

Invoices are checked against the order they belong to, and the odd ones out are surfaced.

Keep the vendor and item catalog clean and deduplicated

One supplier list and one item catalog stay tidy so every document points back to the right master.

Turn plain-language buying requests into a repeatable intake flow

Describe how requisitions should be raised and routed, and get a confirmed, reusable automation.

Make an existing procurement screen safely agent-operable

Let a trusted agent read a live procurement screen and take only the actions that screen already allows.

Keep shelves stocked without watching every SKU

Arin monitors stock against reorder points and drafts replenishment orders, surfacing only the judgment calls.

Turn incoming quote requests into offers faster

Arin triages the quote inbox and drafts offers, escalating the ones that need a human.

Process returns against policy, consistently

Arin runs the returns lifecycle - inspection, restock and refund - against each merchant's policy and records every step.

Route B2B purchases above authority to a recorded approval

Arin enforces account price lists and routes purchases above a member's authority into a recorded approval rather than an inbox.

Stand up a repeatable promotion without engineering

PECO turns a plain-language promotion request into a confirmed, repeatable checkout workflow.

Make the merchant console operable by a trusted agent

Semorel lets a trusted AI agent read the live merchant console and invoke only the authorized commerce actions on screen.

Keep fast-moving locations topped up before they run short

Arin watches replenishment targets and raises top-up requests, escalating to procurement only when the warehouse itself is short.

Catch short-stock orders before they oversell

Arin surfaces lines that cannot fully reserve, with the context to decide split, wait or backorder.

Reconcile the count and flag drift you can actually see

Arin folds the ledger to the summary, flags where a cycle count disagrees, and proposes a named adjustment for approval.

Put damaged stock on hold and clear it without losing the trail

Arin routes flagged units to a blocked location and proposes a write-off that stays on the record.

Turn receiving and put-away into a routine that runs the same way every time

Describe your dock-to-shelf steps in plain language and PECO builds a confirmed, repeatable workflow.

Let a floor assistant act inside the console, but only within the operator's scope

Semorel lets a trusted assistant read live stock context and invoke only the actions the operator is authorized for.

Move routine requisitions through, escalate only the ones a person should see

Arin advances low-risk asset requisitions and surfaces the ones that need a human decision.

Reconcile ordered, received and billed before an invoice is trusted

Arin compares requisition, purchase order, receipt and invoice line items and raises the mismatches.

Run the depreciation schedule and flag the book-value edge cases

Arin exercises the register's depreciation methods and surfaces assets that need a finance decision.

Keep the register accurate across idle, in-repair and end-of-life assets

Arin watches asset status and surfaces the ones due for transfer, repair follow-up or disposal.

Build a new-hire asset provisioning flow in plain language

PECO turns a described onboarding routine into a repeatable requisition-and-assignment workflow.

Let a trusted assistant read the live register and act within scope

Semorel lets an authorized AI agent understand the on-screen asset app and invoke only permitted actions.

Turn operational evidence into review-ready draft journals

Arin reconciles fingerprinted operational pulls against draft entries and routes them for a human to post.

Drive the period-close checklist to the point of sign-off

Arin works the close checklist, completes stages through approval-gated tools, and applies the lock only on explicit human sign-off.

Surface only the bank-reconciliation lines a human needs to judge

Arin proposes matches across cash and bank activity and escalates the unmatched exceptions for confirmation.

Triage AP match exceptions without ever touching payment

Arin reads match results, explains the mismatches, and prepares them for approval - but cannot release a payment.

Build a repeatable evidence-to-draft routine in plain language

A controller describes a recurring pull-and-draft flow in plain language and PECO turns it into a confirmed, repeatable automation.

Let a trusted in-app assistant read the books and run only authorized actions

Semorel lets an operator's AI assistant read live FMS reports and budget guardrails and invoke only the actions its scopes permit.

Keep the OPD schedule and token queue moving without a coordinator babysitting it

Book against real doctor availability and let a human handle only the clashes.

Turn the bed board into a decision queue instead of a phone-around

Match admissions to free beds and flag the bottlenecks a human must clear.

Get lab and imaging results back onto the right chart, and chase the ones that stall

Route completed results to the encounter and flag what is overdue or missing.

Reconcile the encounter's charges before the bill goes out

Assemble OPD bills, room charges and bill items and flag mismatches for finance.

Let an admin build a repeatable new-clinic setup in plain language

Turn a plain-language onboarding request into a confirmed, reusable setup flow.

Give the front desk a trusted assistant that reads the live screen and acts within its role

Let an authorized AI assistant act inside the running app, scoped by role and tenant.

Arth

Java-like syntax, Rust-grade memory safety - no GC, no lifetimes.

Detir

An AI-native GPU UI runtime that renders your app from an IR.

WAID

Write a Vite app, get every platform - web, desktop, iOS and Android, rendered natively.

KilneOS

A sandboxed, GPU-native desktop built to be driven by agents - not your machine.

Arin

An autonomous agent that runs operations and surfaces only the decisions that matter.

PECO

An in-app agent and visual workflow builder - automation, on the record.

Semorel

A client-side SDK: AI agents read your live app and invoke only what you authorize.

Connectors

One governed plane for provider transport, credentials and consent.

Procurement · SCM

Procurement record of truth - one audited surface for people and agents.

Retail · RMS

Agent-ready retail commerce - marketplace and B2B, from catalog to fulfillment.

Healthcare · HMS

Unified, multi-tenant healthcare management - EHR, diagnostics, pharmacy, billing.

Warehousing · WMS

The warehousing system of record - inventory, topology, and pick/pack/ship.

Asset Management · EAM

Asset lifecycle and operational procurement - register to disposal.

Finance · FMS

Governed accounting that connects operational evidence to controlled books.

Manufacturing · MFG

The production system of record - work orders, BOM, routing, and quality-gated completion.

Transport · TMS

The transportation system of record - shipments, carriers, tracking, and proof of delivery.

Banking Ops · BOS

Agent-ready banking exception resolution, with safe execution and full audit.

Workforce · HRMS

Hire to retire on keys you own - provider-neutral people, time and leave.

Lending · LMS

The loan record - borrowers, offers, disbursal and repayment, with decisioning outside it.

Customer · SAM

Sales, marketing and service working one set of accounts and contacts.

ICE

One OAuth 2.1 authorization server for the whole family.

What is an agentic operations platform?

It is software that runs day-to-day operational work autonomously inside a policy you set, rather than assisting a person who runs it manually. The agent reads the same records your team reads, takes the same actions through the same authorization, and stops at the boundary you draw. Arin, PECO and Semorel are three ways of applying that idea - continuous operation, in-app automation, and agent access to your own product.

How is this different from a chatbot on top of an ERP?

A chatbot produces text and leaves the system unchanged; you still perform the action. These agents perform the action and write it to the record. The difference shows up in the failure case: a chatbot that is wrong wastes your time, whereas an agent that acts must be governed - which is why every action runs through scoped authorization and lands on an append-only ledger that shows who or what acted.

Where do Arin, PECO and Semorel differ?

Arin is a single-tenant agent that runs a function continuously - it works procurement in the background, handles the routine within policy, and hands you only decisions that genuinely need judgment. PECO lives inside an application: a plain-language assistant plus a visual builder over one shared action model, so a request becomes a confirmed, repeatable automation. Semorel is a drop-in client-side SDK that lets a trusted agent read what is on screen in your own app and invoke its actions in-session.

What does “on the record” mean in practice?

Human and agent actions carry the same weight in the audit trail. There is no side channel where automation happens off the books and gets reconciled later. Every action is attributable, replayable and scoped by the same authorization model, which is what makes it defensible to an auditor rather than merely convenient to operations.

Do you have to hand over control to adopt this?

No. Autonomy is a setting, not a commitment. Agents run at the level you configure - observe only, propose, act with confirmation, or act within policy - and the boundary is enforced by scoped tokens rather than by prompt instructions. Teams typically start in observe mode on one workflow and widen the envelope as the escalation quality proves itself.

What does this need from the systems you already run?

An agent can only be governed if the thing it acts on has a real record and a real permission model. Where that exists, the platform connects to it. Where it does not, the Agentic Enterprise modules provide it - which is why the systems of record and the agent layer are designed together rather than sold as unrelated products.

What is a system of record, and why does an agent need one?

A system of record is the authoritative source for a domain: not a report or a copy, but the place where the state legally and operationally lives. Agents need one because autonomy without an authoritative record produces work nobody can verify afterwards. If an agent approves a purchase order, the approval has to exist in the same ledger a person's approval would - otherwise you have automation you cannot audit.

How is this different from bolting AI onto an existing ERP?

Most ERP surfaces were built for human input and expose automation as an afterthought - a scripting layer or an integration bus bolted to the side, usually without the permission model that governs the UI. Here the machine-operable surface and the human surface are the same surface, sharing one authorization model and one audit trail, so an agent cannot reach anything a correspondingly scoped person could not.

How do the modules fit together?

Each module owns one domain: SCM owns procurement, WMS owns physical stock, RMS owns retail and quotes, EAM owns asset lifecycle, FMS owns the books, HMS owns clinical and hospital operations, MFG owns production, TMS owns how goods move, and BOS owns banking exception handling. They share identity and authorization through ICE, so a scope granted in one place means the same thing everywhere and evidence produced in one module is usable in another - warehouse receipts and procurement records reconciling into finance, for example.

Do you have to adopt all of them?

No. Each module is a system of record for its own domain and runs on its own. The compounding benefit is real but incremental: adding a second module means the evidence trail extends across a boundary that usually requires manual reconciliation. Most teams start where the manual reconciliation hurts most.

Where does the agent layer come in?

The modules make operations governable; Arin, PECO and Semorel make them autonomous. A module exposes its actions with scopes attached, and an agent performs them under a token that grants exactly those scopes and nothing more. That separation matters: the record does not trust the agent, it trusts the authorization, so the safety property holds regardless of how the agent reasons.

What stays a human decision?

Anything you say does. The design assumption is that the routine majority of operational work is mechanical and the small remainder carries genuine judgment or liability - approving spend above a threshold, releasing a clinical order, posting to the ledger. Agents are built to clear the first category and prepare the second, not to quietly absorb both.

What is an AI-native app runtime?

It is the layer beneath your application - language, renderer and delivery - designed so that a program describing an interface can be rendered for a person and operated by an agent from the same description. Instead of an agent scraping pixels or guessing at a DOM built for humans, it works against a typed representation of what the application can actually do.

Why build a new language for this?

Arth exists because the safety properties this layer needs are usually paid for in ergonomics. It takes Java-like syntax and pairs it with Rust-grade memory safety: no garbage collector, no lifetime annotations, no null, compiled to native code. The point is that systems-level guarantees should not require systems-level ceremony from the person writing ordinary application logic.

How do Arth, Detir, WAID and KilneOS fit together?

Arth is the language. Detir is the renderer - a GPU runtime that draws either HTML or a typed intermediate representation, so the same application has a visual form and a machine-operable form. WAID is delivery: write one Vite and React application and ship a real static website plus native desktop, iOS and Android builds, rendered by Detir rather than wrapped in a WebView. KilneOS is the sandbox - a GPU-native desktop you run as an ordinary application, where an agent gets a real computer to drive while deny-by-default brokers scope what it can reach and a replayable audit records every move.

Does this replace the web?

No, and it is explicitly designed not to. WAID's web target is a genuine static website - crawlable, linkable, cacheable - not an application shell that renders nothing without JavaScript. The goal is to stop treating native and web as separate rewrites, not to abandon the open web in favour of a proprietary surface.

Why does an agent need its own desktop?

Because the alternatives are worse. Giving an agent a shell on a real machine grants far more authority than the task requires, and confining it to a chat window means it cannot use the software people actually use. KilneOS gives it a real desktop with real applications, while the authority it holds is brokered per action and denied by default - so capability and blast radius are decoupled.

Can you adopt one piece without the others?

Yes. WAID builds and ships applications today without requiring Arth. Detir renders HTML as well as its own intermediate representation. The layers are designed to compose, but each solves a problem that stands on its own - which is deliberate, because a runtime you can only adopt all at once is a runtime nobody adopts.

Waid developer documentation

Guides and reference for building, running and shipping apps on the Splenta runtime.