Business Applications: agents that work inside your processes, under control

1. An agent starts small

Take accounts payableAccounts payableThe function that receives, checks and pays supplier invoices.See the glossary →. A first agent reads invoices, matches them to purchase ordersPurchase orderThe document formalising a purchase from a supplier: items, quantities, prices. The invoice must match it.See the glossary →, flags discrepancies and proposes an approval. Four tools, a clear scope, an easy-to-check result: a good start.

Then the requests come: handle disputes, chase suppliers, check payments, apply the purchasing policy, produce the reporting. Each addition is reasonable. Their sum is not.

agent: supplier-invoice-assistant
tools:
  # the starting scope
  - read-invoice
  - match-purchase-order
  - flag-discrepancy
  - propose-approval
  # added over the months
  - open-dispute
  - chase-supplier
  - check-payments
  - schedule-payment
  - search-purchasing-policy
  - update-supplier
  - generate-reporting
  # ...

2. When one agent does too much

It becomes fragile

Instructions grow longer to limit errors, every small change means retesting everything, and nobody dares touch it any more.

It makes mistakes

It calls the wrong tool, passes the wrong parameters, and answers the same question differently.

It costs more

It needs the most powerful models, its instructions grow with every call and it repeats steps. According to Anthropic, 58 tools alone take about 55,000 tokensTokenTwo meanings. For a model: a piece of a word, the unit that measures processed text and therefore cost. In security: a temporary key proving an access right.See the glossary → before the first question.

3. Split into specialised agents

The answer is the same as in software: split. One agent for invoices, one for disputes, one for payments. Each has few tools, short instructions and rights limited to its domain.

• Each agent is simpler to write, test and evolve.
• Each agent is more reliable: fewer possible choices, fewer chances to go wrong.
• Independent tasks can run in parallel, which shortens lead times.

It is not free. Anthropic measures that a multi-agent system uses about 15 times more tokens than a simple chat. Their advice: find the simplest solution possible, and only add complexity when it is needed.

4. A main agent that plans and delegates

Splitting into independent agents has a flaw: each sees only part of the context, and their decisions can conflict. Hence the approach spreading since 2025, popularised by LangChain’s Deep Agents and inspired by Claude Code, Manus and Deep Research: a main agent keeps control of the context and relies on four ingredients.

Detailed instructions

A long, precise system promptSystem promptThe standing instructions given to an agent: its role, its rules, how it works.See the glossary → describing the business, the expected steps and the rules to follow.

A plan

A task list the agent keeps up to date: it forces structure and shows where the agent stands.

A notes space

A file system where the agent stores intermediate results, instead of keeping everything in its working memory.

Subagents

Precise tasks handed to subagents with isolated context; they return a result, the main agent decides.

The principle: one head that decides, hands that execute. You keep the benefits of splitting without losing the thread of the context.

5. Coordination patterns

A main agent that delegates is a form of supervisor. But depending on the process, other ways of making agents work together remain relevant. FrameworksFrameworkA development toolkit that provides an application’s structure; for agents: LangGraph, Strands, CrewAI…See the glossary → and vendors use different names, but the same families appear everywhere.

In real life you combine them: a workflow for the backbone of the process, a supervisor at the step that needs judgement, and human approval before any write.

6. Middleware and hooks: where governance plugs in

An agent runs in a loop: it queries the model, calls a tool, reads the result, starts again. Recent frameworks let you step in at each point of that loop without touching the agent’s core: that is middleware and hooks. This is where controls belong.

The pattern is now the same at every major player, under different names:

Governance becomes code: one library of approved middleware, reused by every agent, rather than rules rewritten in each prompt.

7. What we build

Autonomous agents

Agents that chain several steps of a process: read, analyse, prepare, update, stopping at approval points.

Talk to my data

Ask questions in everyday language about company data (Snowflake, Databricks, business applications) and get quantified, sourced answers, within each person’s rights.

Decision support

Reasoned recommendations, with their sources and confidence level, ready for an expert to approve.

Runtime isolation

Each agent runs in its own environment, with its own rights: an error or misuse stays contained within its scope.

Business connectors

ERPERPEnterprise resource planning software: finance, purchasing, inventory, production.See the glossary →, CRMCRMCustomer relationship management software: contacts, opportunities, interaction history (Salesforce, for example).See the glossary →, ITSMITSMIT service management: tickets, incidents, requests and changes (ServiceNow, for example).See the glossary →, finance tools: agents act inside existing applications, through MCP serversMCP serverThe small service that exposes a tool (an application, a document base) to agents through the MCP protocol.See the glossary → governed by the AI Platform.

8. Guardrails specific to business agents

• Rights limited to each agent’s domain, never an account that “can do everything”.
• Human approval before any write into a system of record.
• Approved, versionedVersioningKeeping every change to a file with its author and date, so you can compare, review and roll back.See the glossary → reference sources: policies, price lists, procedures.
• A full trace of every run: which data, which tools, which decision.
• EvaluationEvaluationTesting an agent on a set of known cases to measure the quality of its answers before updating it.See the glossary → on real cases before every update of an agent or a model.
• A cost cap per agent and per process.
• The ability to suspend an agent in a single operation.

9. Where to start

• Pick a frequent, measurable process where errors are easy to spot.
• Start with a single agent, few tools, read-only.
• Plug in the control middleware from day one: human approval, personal data, caps, logging.
• When the agent grows, move to a main agent that plans and delegates to subagents.
• Choose the simplest coordination pattern that works, often a workflow.
• Add writes into systems only after human approval and quality measurement.