Having an AI agent built

Having an AI agent built or implemented: how to approach it

An agent that works for one day is a demo. An agent that is still running after three months needs a different approach than a clever prompt. We build a working agent or PoC in weeks, on your own knowledge and systems, with a human in the loop where it matters.

Discuss your use case

Who it is for

For teams with a process that takes too much clicking.

The best first agent sits in a process that comes back often, takes a lot of manual work and has a clear check. Then the agent knows when the work is done, and the person knows when to step in. Not sure which process that is yet? Then it starts with discovery.

What we build

Six forms we often build

Workflow automation

A recurring process end to end: fetch data, process it and pass it to the next step. The agent does the clicking, the person decides.

More on workflow automation

Research and monitoring agents

Continuously scanning sources, news or systems, filtering out the signals and summarising what matters.

More on research agents

Internal copilots

An assistant on your own knowledge and data that answers questions, looks things up and drafts, so the team works faster with a better overview.

More on internal copilots

Customer-facing assistants

Agents that handle requests or talk to customers, with clear boundaries and a person watching where it matters.

More on customer assistants

Document and report agents

From raw input, such as calls, data or forms, to a clean document, deck or summary.

More on document agents

Data and integration pipelines

Connecting systems: cleaning and enriching data and moving it reliably from one system to another.

More on data pipelines

How it works

From use case to an agent that keeps working

Five steps. Behind each one sits a piece of engineering that decides whether the agent is still running three months later.

01

A sharp use case

We start with a process that recurs often, takes a lot of clicking and has a clear check. That use case often comes out of discovery.

02

Context and knowledge

What does the agent see at any moment? Context engineering decides which knowledge, documents and instructions go in, so the answer comes from your own source.

03

Build

A working agent or PoC in weeks. The harness around it handles memory, tools and approval gates, and the loop lets the agent gather, act and check its own work.

04

Test with evals and guardrails

Measuring whether it is right, guarding the boundaries and letting a person step in where it matters. Human-in-the-loop is the starting point.

05

Run or hand over

You run the agent yourselves, or we hand it over cleanly to a development partner who turns it into production software.

In practice

What to know before you start

Timeline

Weeks, not months

A working agent or PoC is up and running in weeks.

Principle

Human-in-the-loop

A person approves where it matters, so you can trust what comes out.

Scope

Up to the working prototype

Large production software goes to a development partner, handed over cleanly with the knowledge secured.

Investment

On request

You get a price indication in the introduction call. If the use case is not sharp yet, it starts with a discovery cycle, from €35,000 per department.

Knowledge

On your own source

An internal copilot works on your own knowledge and data, so answers come from your documents.

Proof

35+ agents in our own use

Across seven departments, running 24/7 autonomously with oversight.

Scope

Not every process needs an agent

  • Sometimes it is simply a process problem. We say so honestly, even when the answer to your use case is no.
  • A process that rarely happens or runs differently every time usually yields too little to build an agent for.
  • Looking for a large software project? A development partner builds that. We do the scoping and the prototype.

We use what we build ourselves.

Our own fleet: 35+ agents, 7 departments, 24/7 autonomous with oversight

Frequently asked questions

What teams ask beforehand

01 What does it cost to have an AI agent built? +

That depends on the use case and the systems the agent needs to work with. In a twenty-minute introduction you get a price indication. If it is not yet clear which process comes first, it starts with a discovery cycle, from €35,000 per department, excluding VAT.

02 How quickly is something working? +

A working agent or PoC in weeks, not months. The use case often comes out of discovery; we start from value, not from technology.

03 What do we need to provide? +

Access to the process and the people who do it, the documents and data the agent needs to work on, and someone who reviews the result. That last part stays after the build, because human-in-the-loop is the starting point.

04 Can an agent work with our own company knowledge? +

Yes. That is what an internal copilot does: an assistant on your own knowledge and data that answers questions, looks things up and drafts. The work is in context engineering, deciding what the agent sees at any moment, so the answer comes from your source.

05 What kind of AI agents do you build? +

Agents that do one concrete task, in your own context: workflow automation, research and monitoring agents, internal copilots, customer assistants, document and report agents, and data pipelines.

06 What happens after the prototype? +

You run it yourselves, or we hand it over to a development partner who builds it further as production software. Either way it is handed over cleanly, with the knowledge secured.

07 Do you build this for yourselves too? +

Yes. Back From the Future runs its own fleet of 35+ autonomous agents across seven departments, around one shared context.

Want to go through the concepts at your own pace? See the knowledge base →

Have a use case in mind?

Tell us what is done by hand today. We will tell you honestly whether an agent is the answer.

Discuss your use case