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

> A business agent starts small: one task, a few tools. The trap is to keep adding until it gets lost. The answer: specialised agents, coordinated and isolated.

Source : https://dasein-ai.com/en/articles/business-applications · Dasein · Updated 1 October 2026

## In short

- A single agent that keeps accumulating tools becomes fragile, confused and costly.
- The approach becoming widespread: a main agent that plans, takes notes and delegates to subagents, as in LangChain’s Deep Agents.
- Controls plug into the agent loop through middleware and hooks: human approval, data masking, caps, logging. Dasein helps design them and put them in place.

## 1. An agent starts small

Take accounts payable. A first agent reads invoices, matches them to purchase orders, 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.

Simplified example: an agent that grew one tool at a time.

```
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 tokens 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 prompt 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. Frameworks and vendors use different names, but the same families appear everywhere.

*Diagram: The coordination patterns between several agents.*

| Pattern | Principle | When to use it | Watch out for |
| --- | --- | --- | --- |
| Workflow | Fixed steps defined in advance; independent tasks run in parallel. | Known, repetitive process: matching, checks, closing. | Rigid when facing unforeseen cases. |
| Supervisor | One agent receives the request and calls specialised agents as tools. | Varied requests within one domain. | The supervisor must know each agent well; it is a single checkpoint. |
| Hierarchical | A planner agent splits the request and hands each part to a domain supervisor. | Processes spanning several departments. | Delays and costs add up at each level. |
| Graph | Agents linked by explicit transitions; the model picks the branch, with loops allowed. | Processes with branches: check, correct, re-check. | Bound the loops so they cannot run forever. |
| Swarm | Agents hand off to each other on their own, with shared memory. | Open research, exploring an ill-defined problem. | The least predictable: traceability is essential. |

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.

*Diagram: The points in the agent loop where middleware and hooks plug in.*

| When | What we plug in |
| --- | --- |
| Before the agent | Check the request and the user’s rights, load the right context. |
| Before each model call | Mask personal data, summarise an overlong context, pick the useful tools. |
| Around the model call | Call cap, retry, fallback to another model on error. |
| Around each tool call | Human approval before a write, rights check, call cap, block or fix parameters. |
| After the agent | Log the run, evaluate the answer, trigger a review. |

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

| Framework | Mechanism |
| --- | --- |
| LangChain and Deep Agents | Middleware (before and after the agent or model, around model and tool calls), including ready-made ones: human approval, personal data, caps, model fallback, context summarisation |
| Claude Agent SDK (Anthropic) | Hooks: before and after each tool (to allow, deny, ask or modify), on prompt submit, when a subagent stops |
| OpenAI Agents SDK | Input, output and tool guardrails that stop the run, plus lifecycle hooks |
| Strands Agents (AWS) | Hooks, for example before a tool call to cancel it or rewrite its parameters |
| Google ADK | Callbacks before and after the agent, the model and each tool |

> 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** : ERP, CRM, ITSM, finance tools: agents act inside existing applications, through MCP servers 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, versioned reference sources: policies, price lists, procedures.
- A full trace of every run: which data, which tools, which decision.
- Evaluation 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.

## Further reading

- [Anthropic: Building effective agents](https://www.anthropic.com/engineering/building-effective-agents)
- [Anthropic: How we built our multi-agent research system](https://www.anthropic.com/engineering/multi-agent-research-system)
- [Anthropic: advanced tool use (tool search)](https://www.anthropic.com/engineering/advanced-tool-use)
- [Microsoft: AI agent orchestration patterns](https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/ai-agent-design-patterns)
- [Strands Agents: multi-agent patterns](https://strandsagents.com/docs/user-guide/sdk/multi-agent/multi-agent-patterns/)
- [Strands Agents: agents as tools](https://strandsagents.com/docs/user-guide/sdk/multi-agent/agents-as-tools/)
- [Strands Agents: swarm](https://strandsagents.com/docs/user-guide/sdk/multi-agent/swarm/)
- [Strands Agents: graph](https://strandsagents.com/docs/user-guide/sdk/multi-agent/graph/)
- [Strands Agents: workflow](https://strandsagents.com/docs/user-guide/sdk/multi-agent/workflow/)
- [A2A: specification](https://a2a-protocol.org/latest/specification/)
- [LangChain: Deep Agents](https://www.langchain.com/blog/deep-agents)
- [LangChain: Deep Agents documentation](https://docs.langchain.com/oss/python/deepagents/overview)
- [LangChain: Deep Agents harness](https://docs.langchain.com/oss/python/deepagents/harness)
- [LangChain: LangChain and LangGraph 1.0](https://www.langchain.com/blog/langchain-langgraph-1dot0)
- [LangChain: built-in middleware](https://docs.langchain.com/oss/python/langchain/middleware/built-in)
- [LangChain: custom middleware (hooks)](https://docs.langchain.com/oss/python/langchain/middleware/custom)
- [Claude Agent SDK: hooks](https://code.claude.com/docs/en/agent-sdk/hooks)
- [OpenAI Agents SDK: guardrails](https://openai.github.io/openai-agents-python/guardrails/)
- [OpenAI Agents SDK: lifecycle hooks](https://openai.github.io/openai-agents-python/ref/lifecycle/)
- [Strands Agents: hooks](https://strandsagents.com/docs/user-guide/concepts/agents/hooks/)
- [Google ADK: callbacks](https://adk.dev/callbacks/)
- [Cognition: Don’t build multi-agents](https://cognition.com/blog/dont-build-multi-agents)
- [LangChain: How and when to build multi-agent systems](https://blog.langchain.com/how-and-when-to-build-multi-agent-systems)
