Large Language Model

What a Large Language Model actually is

A Large Language Model is a neural network trained on hundreds of billions of words of text, code, and structured data. The training objective is deceptively simple: predict the next token (roughly, the next word fragment) given everything that came before. Repeat that objective across an enormous corpus and the model develops a working representation of grammar, facts, formatting conventions, and reasoning patterns.

For finance leaders, the practical takeaway is this: an LLM is a general-purpose language engine. It does not know your customer master, your dispute codes, or your cash application rules out of the box. What it brings is the ability to read unstructured text (a remittance email, a scanned invoice, a credit memo, a customer complaint) and produce structured output (a JSON payload, a draft reply, a summary, a classification).

How LLMs work in plain language

Modern LLMs are built on the transformer architecture, introduced by Google researchers in 2017 and scaled aggressively by labs like OpenAI, Anthropic, Google DeepMind, and Meta. The transformer uses a mechanism called attention, which lets the model weigh how relevant each word in the input is to every other word. That is what allows an LLM to follow a long invoice description, link a remittance line to the correct open invoice, or hold a multi-turn dispute conversation.

Three numbers matter when comparing LLMs in a finance context:

• Parameter count: the size of the model, often in the hundreds of billions, which correlates with reasoning quality.
• Context window: how much text the model can consider at once, typically 100K to 1M tokens for current frontier models. This matters when you feed it a full statement of account or a 40-page customer contract.
• Cost per token: the price of inference, which at enterprise invoice volumes turns from a rounding error into a real line item.

Where LLMs matter in finance and AR

LLMs are not a finance product. They are a capability that unlocks several AR workflows that were brittle or impossible with traditional automation:

• Remittance and invoice understanding: extracting payer, invoice numbers, amounts, deductions, and reason codes from PDFs, emails, and portal screenshots. Combined with a vision model, this is the engine behind modern auto cash application.
• Dispute and deduction classification: reading a short text reason (damaged in transit, pricing mismatch on PO 4471) and mapping it to the correct dispute code and routing path.
• Customer email triage: parsing inbound AR mailboxes, classifying intent (payment confirmation, dispute, copy-invoice request), and drafting a response.
• Finance copilots: letting a credit controller ask show me all overdue invoices for accounts with a deduction open more than 30 days in EMEA in plain English and getting a useful answer.
• AR insight summaries: turning a 50-row aging report into a three-bullet narrative for a Monday cash call.

Strengths and limitations finance teams should plan for

The strengths are real. LLMs are structure-agnostic, which is exactly what unstructured AR inputs demand. They handle the long tail (every customer formats their remittance differently) without anyone writing a new template. They offer a natural-language interface that lowers the barrier for finance users to interact with their own data.

The limitations are equally real and should shape any production design:

• Hallucination: LLMs will sometimes generate confident, plausible, and wrong output. They might invent an invoice number that does not exist.
• No native math: LLMs are weak at arithmetic. Any cash posting, balance, or calculation should be done deterministically in code, not in the model.
• Context window limits: even a million-token window has an end. Long contract reviews still need chunking and retrieval strategies.
• Cost at scale: at a few cents per thousand tokens, processing a million invoice lines per month adds real euros to the run rate. Model choice (frontier vs smaller) becomes an architectural decision.

LLMs are not the same as agentic AI

This is the distinction enterprise finance buyers most often miss. An LLM, on its own, is a function: text in, text out. It cannot click a button in your ERP, query your data warehouse, hold persistent memory between sessions, or plan a multi-step workflow.

Agentic AI wraps an LLM with three additional capabilities: tool use (calling APIs, querying databases, posting to the ERP), planning (breaking a goal like clear today's unapplied cash into ordered steps), and memory (remembering that this customer always pays short by the freight charge). The LLM is the reasoning engine. The agent is the operator. AR automation that delivers real outcomes (cash posted, disputes resolved, dunning sent) is agentic. The LLM is one component inside it.

Production guardrails for finance use

An LLM going into the GL is not the same risk profile as an LLM drafting marketing copy. Five guardrails should be non-negotiable for any AR or O2C deployment:

• Deterministic checks on every number: the LLM proposes, code verifies. Sum of allocations must equal the payment amount, full stop.
• Confidence thresholds: high-confidence matches post automatically; lower-confidence items route to a human queue with the LLM's reasoning shown.
• Audit trail per decision: every model output, prompt, version, and source document captured for SOX and internal audit review.
• Human-in-the-loop on edge cases: write-offs above a threshold, new customer disputes, and unmatched cash always surface for human approval.
• Data residency and privacy controls: invoice and customer data should not be used to train third-party foundation models. Look for zero-retention API contracts and EU data residency where applicable.

Used this way, LLMs stop being a science project and start behaving like infrastructure: invisible to the controller, but doing the reading, classifying, and drafting that used to consume entire FTE-weeks every month.

Frequently asked questions

Is a Large Language Model the same as ChatGPT?

No. ChatGPT is a consumer product built on top of an LLM (OpenAI's GPT family). The LLM is the underlying model. The product is the chat interface, the safety layer, and the memory wrapped around it. Enterprise finance teams typically access LLMs through APIs from providers like OpenAI, Anthropic, Google, or via open-weight models hosted privately, not through the consumer chat app.

Can an LLM post cash directly to our ERP?

Not on its own, and it should not be asked to. The LLM can read a remittance, propose an allocation, and explain its reasoning. The actual posting should go through deterministic code with validation rules (sum checks, customer master lookup, open-invoice matching) and an audit trail. That separation is what makes the workflow safe for finance.

Will an LLM hallucinate invoice numbers or amounts?

It can, which is why production AR systems never trust raw LLM output for numerical fields. The pattern is: LLM extracts candidate values, code validates them against the open AR ledger, and only confirmed matches post automatically. Anything that does not validate routes to a human with the model's reasoning attached.

How is an LLM different from traditional OCR?

Traditional OCR converts pixels to characters and relies on rigid templates to find fields. It breaks the moment a customer changes their remittance format. An LLM (usually paired with a vision model) reads the document the way a human does: it understands that Inv 4471 less 2% disc refers to a specific invoice and a deduction. That is why LLM-based extraction handles the long tail without per-customer template maintenance.

What does an LLM cost to run at enterprise AR volume?

It varies with model choice and document complexity, but a useful rule of thumb is that processing a typical remittance through a frontier model costs cents, not euros. At a million transactions per year, that becomes a real budget line. Smart deployments use a smaller, cheaper model for routine extraction and reserve frontier models for complex disputes or escalations.

Do we need agentic AI, or is an LLM enough?

If your goal is to read documents, summarise data, or draft text, an LLM is enough. If your goal is to actually clear unapplied cash, resolve disputes, or run dunning without human intervention, you need agentic AI: an LLM plus tool use, planning, and memory. Most finance buyers want outcomes, not summaries, which is why the market is moving from LLM features to agentic AR platforms.