ACUMATICA AI ARCHITECTURE
The Safest, Upgrade Compatible Architecture for Connecting AI Agents to Acumatica
Photo by Albert Stoynov on UnsplashThe wrong AI architecture breaks at your next Acumatica upgrade or exposes the ledger to an ungoverned write. The right one rides on the interfaces Acumatica commits to keeping stable, touches nothing in the core, and lets a person approve every change. Here is what that looks like.
- Build on the contract based REST API and OData, which Acumatica maintains across releases, so your integration survives version upgrades.
- Avoid deep customization dependencies; an agent that relies on modified screens or database triggers is fragile at upgrade time.
- Use OAuth 2.0 with a dedicated least privilege role rather than database credentials.
- Keep write back human approved, so no agent can post to the ledger on its own.
- ChatFin follows this architecture: API first, customization light, governed write back, full audit trail.
Acumatica is a cloud ERP with a regular release cadence, two feature releases a year. Any AI architecture you choose has to keep working across those releases. That single requirement rules out several tempting shortcuts and points to a clear, durable pattern.
The other half of safety is the ledger itself. A finance agent must never be able to post an unapproved transaction. Architecture, not good intentions, is what enforces that.
Principle one: build on stable interfaces
Acumatica commits to its published integration surface. The contract based REST API exposes business objects mapped to screens and enforces the platform's own validations, and Generic Inquiries can be published as OData feeds. Because Acumatica maintains these interfaces across versions, an integration built on them keeps working when you upgrade.
Photo by Kelly Sikkema on UnsplashStable interfaces survive upgrades
Integrations that go through documented APIs tend to survive ERP releases. Integrations that reach into tables or screens tend to break on the next patch.
NetSuite could interoperate with other business systems in the portfolio over more traditional APIs.
Craig Sullivan, on the AgentCFO podcast
That is the whole case for principle one below. Build on the interface the vendor has promised to keep stable.
Principle two: do not depend on customizations
The most common cause of a broken integration at upgrade time is a dependency on modified screens, custom database objects, or triggers in the core. Those can shift between releases. A safe agent reads and writes through the standard API and, where a specific data shape is needed, through a purpose built Generic Inquiry, which is a supported, configuration level artifact rather than a code change.
Principle three: authenticate with least privilege
Security and upgrade safety reinforce each other. Authenticate with OAuth 2.0 and a dedicated integration role scoped to only the objects the workflow needs. This keeps the blast radius small and avoids the brittleness of embedding credentials in customizations.
Principle four: never let the agent post alone
Photo by Homa Appliances on UnsplashThe ledger is protected by workflow, not by trust. In a safe architecture the agent prepares a draft, a person reviews it, and only the person releases it. This is true whether the draft is an AP bill, a journal entry, or a payment. The agent's autonomy ends where the posting begins.
Why this matters at scale. Human approval on drafts is what lets you raise automation levels safely: the more the agent prepares correctly, the less time approval takes, but the control never leaves your team.
Principle five: log everything
Every read and every proposed write should be captured. A complete audit trail satisfies auditors, supports internal control, and gives you a record to review when something looks wrong. Acumatica also meters API calls against your license tier, so logging doubles as cost visibility.
What this architecture is not
How ChatFin implements it
ChatFin is API first, customization light, and approval driven. It connects through the contract based REST API and OData under OAuth 2.0, avoids dependencies on modified core objects, prepares drafts for human release, and records every action. That is why a ChatFin deployment keeps running through Acumatica upgrades instead of breaking on them.
A safe Acumatica AI architecture touches the interfaces Acumatica promises to keep, and touches nothing it does not have to.
Frequently Asked Questions
Will an AI integration break when I upgrade Acumatica?
It will not if it is built on the stable, published interfaces. The contract based REST API and Generic Inquiry OData feeds are maintained across releases, so an integration that uses them survives upgrades. Integrations break when they depend on modified screens, custom database objects, or screen scraping, which can change between versions.
Is it safer to connect AI through the API or the database?
Through the API. The contract based REST API enforces Acumatica validations and workflow rules and is governed by OAuth 2.0 with role based scopes. Direct database access bypasses those controls, is harder to secure, and is more likely to break at upgrade time. A safe architecture never uses shared database credentials.
How do I stop an AI agent from posting a wrong transaction?
Architect the workflow so the agent only prepares drafts and a person approves and releases them. The agent's autonomy ends at the point of posting. Combined with least privilege access and a full audit trail, this ensures no unapproved change ever reaches the ledger. ChatFin follows this human approved pattern by default.
Build on an Architecture That Lasts
ChatFin gives Acumatica teams an upgrade compatible architecture: API first access, no dependency on core customizations, OAuth 2.0 with least privilege, and human approved write back with a full audit trail.
Deploy on your existing Acumatica instance without replacing it, without database credentials, and without waiting for a development project. ChatFin reads through the same governed API surface Acumatica already exposes and writes back only drafts that a human approves.