DEV Community: Arfinex

Authority levels for finance AI agents: a small policy model you can test

Arfinex — Wed, 04 Nov 2026 07:20:07 +0000

Most discussions about AI agents in finance stop at "keep a human in the loop". That sentence is true and almost useless to an engineer, because it does not say which loop, which human, or what happens when the human is not there. This post is about turning it into something you can write down, review and test.

Four actions, four levels of authority

Start by listing what an agent can actually do. In a finance system, the list is short:

Notify: send an internal reminder or flag an exception.
Draft: build a journal entry, a payment proposal or a report, without posting it.
Post: record a final, balanced entry in the ledger.
Pay: initiate an outgoing payment.

These are not the same risk. A wrong reminder costs a minute. A wrong posted entry changes a report someone already used. A wrong payment may not come back. So each level gets its own rule: which role may allow it, up to what amount, whether a second approval is needed, and what stops it.

Policy as data, not as prompt text

The tempting shortcut is to put the rules in the agent's prompt ("never pay more than 5,000 without approval"). Prompts are not a control. They are not versioned with the books, they cannot be audited, and a model can misread them. Put the policy in data, and let deterministic code enforce it after the model has proposed something.

type Level = "notify" | "draft" | "post" | "pay";

interface Rule {
  level: Level;
  allowedRoles: string[];
  maxAmount?: number;          // in reporting currency
  secondApproval: boolean;
  stopIf: StopCondition[];
}

type StopCondition =
  | "destination_account_changed"
  | "over_limit"
  | "missing_document"
  | "unusual_amount_change"
  | "sources_disagree";

const policy: Rule[] = [
  { level: "notify", allowedRoles: ["agent"], secondApproval: false, stopIf: [] },
  { level: "draft",  allowedRoles: ["agent"], secondApproval: false, stopIf: ["sources_disagree"] },
  { level: "post",   allowedRoles: ["accountant", "controller"], maxAmount: 20000,
    secondApproval: false,
    stopIf: ["missing_document", "unusual_amount_change", "sources_disagree"] },
  { level: "pay",    allowedRoles: ["treasurer"], maxAmount: 10000,
    secondApproval: true,
    stopIf: ["destination_account_changed", "over_limit", "missing_document"] },
];

The numbers above are examples. The point is the shape: every action the agent proposes is checked against a rule it did not write.

The check happens outside the model

The agent proposes. A plain function decides.

function decide(p: Proposal, rule: Rule, ctx: Context): "run" | "wait" | "stop" {
  const hit = rule.stopIf.find(c => ctx.detects(c, p));
  if (hit) return "stop";                                   // a person must look
  if (rule.maxAmount && p.amount > rule.maxAmount) return "wait";
  if (!rule.allowedRoles.includes(ctx.instructedBy.role)) return "wait";
  if (rule.secondApproval && !ctx.hasSecondApprover(p)) return "wait";
  return "run";
}

Three outcomes matter. Run means the action is inside what the organization already approved. Wait means it needs a named person. Stop means something looks wrong and nobody should approve it without reading the evidence first.

Because decide is ordinary code, you can unit-test it: a payment to a changed bank account must always return stop, whatever the model said in its explanation.

Keep facts, inferences, suggestions and decisions apart

When an agent explains itself, it mixes four kinds of statement:

a fact that came straight from a source (a bank line, an invoice),
an inference made by combining data,
a suggestion for the next action,
a decision that only an authorized person can make.

Store them as separate fields, not one paragraph. A reviewer can then see at a glance that "this invoice is probably a duplicate" is an inference, and that the decision field is still empty.

Log every run so it can be replayed

For each run, record the time, the sources read, the version of the rule used and the result. If a recurring workflow runs monthly, a change in the rule creates a new version instead of silently changing old results. That is what lets an auditor ask "why was this posted?" months later and get an answer that is not "the model thought so".

Arithmetic is not the model's job

Let the model read documents, extract lines and propose matches. Let deterministic code do the calculation, the debit-equals-credit check and the final posting. Balances should be the sum of entries, and corrections should be reversing entries, never edits.

If you are designing something similar, the one test worth writing first is the boring one: feed your decision function a payment whose destination account changed yesterday, and make sure it stops.

This article was written with the help of AI and reviewed for accuracy before publishing.

Can AI Post Journal Entries? Where Agents Stop and Approval Starts

Arfinex — Wed, 28 Oct 2026 07:26:16 +0000

A plain answer for CFOs, controllers and finance managers of multi-entity organizations

Can AI post journal entries? It can prepare them, but in a well-controlled finance team it should not post them on its own. In Arfinex, AI agents read, compare, find differences and draft a proposal with its sources; one person records the entry, a different person approves it, and every figure comes from the ledger.

Why "can AI post journal entries" is the wrong first question

Most finance teams are not asking whether a model is clever enough to write a debit and a credit. They are asking who is accountable when that entry is wrong. An auditor will ask the same thing: who proposed it, which documents support it, who approved it and when.

So the useful question is: which steps can an AI agent take, and where does human approval start?

What an AI agent can do with journal entries

In Arfinex, each agent has a separate role and a written authority table. Observing, analysing, proposing and drafting are allowed. In practice, that means an agent can:

Read bank and payment sources, the ledger and open items after the nightly close.
Compare them and flag a difference, such as an unmatched receipt or an unbalanced balance.
Draft a proposed correction, labelled as a proposal, with links to the entries and documents it relies on.
Explain a movement in plain words for the morning brief, citing its sources.

Each finding comes with its evidence, its source and a confidence level, and fact is kept apart from inference.

Where the agent stops

Execution needs permission, and anything that touches money needs management approval. Anything that would change the books goes through the normal recording and approval path:

A person records the entry. The agent's draft is a starting point, not a posting.
A different person approves it. Recorder and approver are never the same person.
An unbalanced entry never becomes final, and re-entry with the same reference number creates no duplicate.
A posted entry is never edited. A correction arrives as a new reversing entry, so the history stays intact.

Figures themselves are produced by deterministic, tested calculation from the ledger. The AI quotes figures; it does not invent them. A number in AI text that cannot be traced to a source is rejected in review.

A simple example

On Tuesday morning the reconciliation agent finds a bank receipt that matches no open invoice. It drafts a proposal: allocate the receipt to a customer account, with the bank line and the likely invoice attached as evidence. The accountant reviews it, records the entry, and the finance manager approves it. If the allocation later proves wrong, a reversing entry fixes it, and the trail shows who proposed, who recorded, who approved and what changed.

A short checklist before you let AI near your ledger

Every figure comes from tested calculation on the ledger, not from the model.
Every AI draft is labelled as a proposal until a person approves it.
Every proposal links to its entries, reconciliation items or documents.
Each agent has a written list of what it may observe, draft and propose, and what it must never do.
Recording and approval of sensitive changes are done by two different people.
The record of proposals, edits and approvals is kept and exportable with the rest of your data.

The answer, in one line

AI should prepare journal entries and find what is wrong; people should post and approve them. That keeps the speed of automation and the accountability of a controlled close.

See how this works in Arfinex accounting, with AI agents and human approval: Arfinex ERP accounting with AI agents

Arfinex builds software only. Local accounting and tax treatment is confirmed by your own accountant or adviser.

Building finance software where every number has a source

Arfinex — Thu, 22 Oct 2026 07:44:03 +0000

Most financial losses inside a company are not dramatic. They are small and repetitive: a duplicate supplier payment, a seat licence nobody uses, a payment fee a little above contract. Spotting them requires being able to trace every number back to where it came from.

That idea sits at the core of Arfinex, the financial operating system for organizations, powered by AI agents. Arfinex LLC builds and provides the platform, which connects ledger, treasury, sales, payroll, contracts and operations in one current management view, in English, Persian, Arabic and Turkish.

Design principles

No number without a source. Every money movement links to the invoice, contract, bank line or report behind it.
A balanced double-entry ledger as the reference system. Balances are built from balanced entries.
Corrections are reversals, not edits. Approved reversing entries keep the audit trail intact.
AI analyzes, people decide. Specialist AI agents surface discrepancies and the decisions that need attention, draft entries and suggest matches. Postings, calculations and money movement follow deterministic, approved rules, and the manager keeps the final say.

Scope

Arfinex is a software builder only. Payments, custody and identity checks are handled by licensed providers.

Read the full article on the Arfinex website: https://arfinex.com/en/insights/arfinex-smart-accounting