Skip to main content
Skip to content
Generative AI

Agentic Workflows

Routine work your team can hand to an agent: an event, a schedule or an API call starts it, and the cases that need a person still reach one.

01 / 04

Automation breaks on the first exception

A scripted flow handles the case that looks like last week's. The one with a missing field stops the queue and waits for a person, and nobody sees it until morning.

CH.01 · The problem

Automation breaks on the first exception.

  1. Rules cover the happy path

    A scripted flow handles the invoice that looks like last week's. The one with a missing PO number stops the queue and waits for a person.

  2. Every change is a ticket

    A new supplier format, a new field in the CRM, a new approval rule. Each one means someone rewrites the script.

  3. Nobody sees what ran

    When a flow fails silently at 3 a.m., the first sign is a customer email the next morning.

Our answer

Agents that reason through the case

An agent reads the case, decides what to do with the tools it is allowed to use, and hands the odd ones to a person. Every step is written to a log you can read.

CH.02 · What we build

How we build it

Three layers, each one tested on its own before an agent is trusted with a real case.

Decisions in contextSeveral agents, one caseNew cases without new codeVolume without a queue
01

Agent design

What each agent may do, and what it must ask about.

  • Write the task in one sentence with its inputs and outputs
  • List the tools the agent may call, and nothing else
  • Define the cases it must hand to a person
  • Set the budget per run: steps, tokens, time
  • Write the failure cases before the happy path
02

Orchestration

How the agents pass a case between them.

  • Choose the trigger: event, schedule or API call
  • Map the hand-offs and what each agent receives
  • Add the human step where a decision needs one
  • Persist state so a run can resume after a failure
  • Log every action with its inputs and result
03

Integration

The tools the agents use are your systems.

  • Connect ERP, CRM, mail and ticketing through their APIs
  • Scope each connection to the least access needed
  • Wrap writes in checks the agent cannot skip
  • Run the model locally or through a no-retention route
  • Test each tool against the live system in read-only mode
CH.03 · How it runs

How it runs

Four phases from one process on paper to agents running it.

  1. 01Phase 1

    Discovery

    Pick one process, walk it end to end, write the failure cases.

    • Choose the process with the most manual routine
    • Walk it with the people who run it today
    • List the systems and the data each step touches
  2. 02Phase 2

    Agent build

    One agent at a time, on real cases, read-only first.

    • Build the first agent against historical cases
    • Add the tools, one at a time, read-only
    • Compare its decisions with the team's
  3. 03Phase 3

    Orchestration

    Wire the trigger, the hand-offs and the human step.

    • Connect the trigger to the live event
    • Implement the hand-offs between agents
    • Build the review list for flagged cases
  4. 04Phase 4

    Production

    Ship, watch the log, hand over.

    • Enable autonomous runs on the agreed cases
    • Watch the flagged list and the log daily
    • Tune the hand-off rules with the team
CH.04 · What changes

What changes

The routine leaves the inbox. People keep the decisions.

Exceptions reach a person

The agent handles what it can and writes down why it stopped on what it could not. The person opens a case with the evidence attached.

Changes stop costing tickets

A new supplier or a new field is handled by the agent reading the document, so the flow keeps running while the layout changes.

Every run is on record

Trigger, actions, tools called, the result. One log per run, readable by the people who own the process.

Side by sideScripted automationAgentic workflow
DecisionsFixed rules on known fieldsRead from the case, within set limits
A new document layoutBreaks until someone rewrites the scriptRead like any other
ExceptionsStop the queueGo to a person with the evidence
VolumeOne at a time, in orderIn parallel, flagged cases in one list
RecordA status codeEvery action, input and result per run
CH.05 · Questions

Questions

A scripted flow follows the rules it was given and stops at anything else. An agent reads the case and chooses an action from the tools it is allowed to use. It still has limits: the tools, the budget per run, and the cases it must hand to a person are all set by you.

Routine work with documents or records and a few exceptions: invoice processing, ticket triage, order intake, onboarding checks, report preparation. The first one we pick together in discovery, by volume of manual work and by how clearly done can be measured.

Discovery is two weeks at a fixed price. The first agent runs on historical cases within weeks, in read-only mode. Writes are enabled once its decisions match the team's on the agreed sample, and a week in shadow mode comes before autonomous runs.

More in Generative AI

The map of the practice

Back to Generative AI
Start

Bring us the problem nobody has cracked yet.

We are a small team of senior specialists. We pick the right model and the right layer, and we build the least machinery that does the job. You get a call with an engineer, not a sales deck.