---
title: "From AI Agent Pilot to Production in 90 Days, With the Gates in Between"
description: "Most agent pilots die between the demo and the deployment. This is the 90-day plan we use to get an agent into real production volume, including the four gates where the honest answer is sometimes to stop."
image: "https://foundrysoft.co/api/og?type=article&title=From+AI+Agent+Pilot+to+Production+in+90+Days%2C+With+the+Gates+in+Between&cat=Business+%2F%2F+AI+Strategy&rt=12+min+read&au=Varun+Raj+Manoharan&dt=2026-08-26"
url: "https://foundrysoft.co/blog/agent-pilot-to-production-90-days"
---

Business // AI Strategy 2026-08-26 12 min read

# From AI Agent Pilot to Production in 90 Days, With the Gates in Between

Most agent pilots die between the demo and the deployment. This is the 90-day plan we use to get an agent into real production volume, including the four gates where the honest answer is sometimes to stop.

![Varun Raj Manoharan](https://foundrysoft.co/images/about/founder.webp)

Varun Raj Manoharan Founder & Principal Engineer

AI Agent Deployment Agentic AI AI Implementation Enterprise AI Shadow Mode

## Key takeaways

-   Shadow mode is the highest-value phase and the one most often skipped. Run the agent alongside the humans, compare every output, act on none of it.
-   Four gates, at roughly weeks 2, 6, 10, and 13, with a written stop condition at each. A plan without a stop condition is not a plan, it is an intention.
-   Roll out by case category, not by percentage of traffic. Start where mistakes are cheap and reversible, and earn your way to the expensive cases.
-   The measurement you need at day 90 is cost per completed task and escalation rate. If you did not capture the human baseline in week one, you cannot produce either.

The gap between an agent that works in a demo and an agent that works on Tuesday afternoon in November is where most of these projects die. Not because the technology fails. Because nobody planned the crossing.

This is the plan we use. It is not the only one that works, and the timings shift with the complexity of the process, but the shape has held up across enough builds that I trust it. Ninety days, four gates, and a written condition at each gate under which the correct decision is to stop.

That last part is the bit that gets removed from most plans, and it is the reason those plans produce projects that stagger on for three quarters.

## Weeks 1 and 2: the baseline and the real process

Two things happen and no code gets written.

You measure the current state. How many times does this process run per month. How long does each instance take, measured properly rather than estimated in a meeting. Who does it. What does an error cost when one happens, and how often does one happen today. That last figure matters enormously and almost nobody has it, which means the agent gets held to a standard of perfection the humans were never held to.

And you find out what the process actually is, by watching people do it rather than reading the documentation. There will be exceptions nobody wrote down, a spreadsheet somebody maintains privately, and at least one rule that exists because of an incident in 2021. This is the single highest-return activity in the entire ninety days.

In parallel, start the credential provisioning requests. They will take longer than anything else and there is no way to compress them from inside the project.

**Gate 1, end of week 2.** Do the arithmetic. Volume times time saved per instance, minus the escalation load you expect, against the cost of building and running it. Stop condition: if the annual value is less than roughly three times the build cost, pick a different process. Not because a smaller return is worthless, but because your estimates at this stage are not accurate to better than a factor of two, and a thin margin now is a negative one later.

I have killed projects at this gate and every time it felt bad and was correct.

## Weeks 3 to 6: build against the ugly data

Build the tools first, then the agent. The tools are where the reliability lives: auth, scoping, rate limits, retries, logging. Get those right once and the agent layer on top is comparatively simple.

Build against a genuinely random sample of real inputs from the last month, including everything that got escalated. Not a curated set. This will make your early numbers look bad and that is the entire point, because it directs your effort at the failure modes that will actually occur rather than at polishing a happy path that was never in doubt.

Design the permission model in this window, not later. What the agent can read, what it can write, what requires a human, what is impossible. Doing it now costs a couple of days. Doing it after the security review costs a quarter.

By the end of week 6 you want an agent that runs end to end on real inputs and produces output you can compare against what a human did.

**Gate 2, end of week 6.** Compare a sample of at least a hundred real cases. Stop condition: if the agent is not within striking distance of human quality on the straightforward cases, meaning perhaps 10 percentage points, the problem is usually the data or the process definition rather than the model, and another month of prompt work will not close it. Go back to week 1 or stop.

The other stop condition here is subtler. If the failures have no pattern, that is worse than a high failure rate with a clear pattern. Patterned failures are fixable. Scattered ones usually mean the task is genuinely ambiguous, and an agent will not resolve ambiguity that the business has never resolved.

## Weeks 7 to 10: shadow mode

This is the phase people skip and it is the one that decides whether the deployment succeeds.

The agent runs on every real case, in parallel with the humans, and its output is recorded and compared. Nothing it produces is acted on. Nobody downstream sees it.

You get four things from this that you cannot get any other way.

A real accuracy number on the true distribution of inputs, including the weird ones that only appear at volume. Your sample of a hundred did not contain the case that turns up eleven times a month.

Real cost data. Cost per completed task, on real traffic, including the retries. This is the number that goes in front of finance and it is meaningless before you have production-shaped traffic.

Disagreement analysis, which is the most interesting output. Where the agent and the human differed, who was right? In my experience the human is right most of the time and not all of the time, and the cases where the agent was right are worth reading carefully, because they usually reveal an inconsistency in how the process is performed.

And trust. The team watching the agent get things right for four weeks is a completely different team from the one that gets told it works. Nothing else produces that.

Four weeks is the minimum I would run this. It is long enough to see monthly cycles and short enough that momentum survives.

**Gate 3, end of week 10.** Stop condition: if the agent's error profile includes any category where a mistake is expensive and undetectable, do not proceed to production for that category, whatever the aggregate accuracy is. Aggregate accuracy hides exactly the risk you care about. A 96% agent that is wrong in a way nobody notices on high-value cases is worse than a 90% agent whose errors are loud.

## Weeks 11 to 13: staged rollout by category

Now it acts, and the sequencing here matters more than most teams appreciate.

Do not roll out by percentage of traffic. Ten percent of everything gives you a small amount of every risk, including the ones you are least ready for. Roll out by case category, starting with the ones where a mistake is cheap and reversible.

For a support agent, that is informational queries before anything touching an account. For a finance agent, low-value transactions with a human-visible reconciliation before anything above a threshold. For a document agent, internal consumption before anything a customer sees.

Each category runs for a week with elevated review before the next one opens. If a category misbehaves, you close it without affecting the others, which means you never have to roll back the whole deployment.

Keep the humans in the loop on anything irreversible from day one, and resist the pressure to remove that gate early. It usually costs less throughput than people fear, because irreversible actions tend to be a small share of volume.

**Gate 4, end of week 13.** You should be able to state: the agent handles X% of volume autonomously, escalates Y%, costs Z per completed task against a human baseline of W, and its error rate on the categories it handles is comparable to or better than the previous process.

If you cannot state that, you do not have a production agent. You have a pilot that stopped being reviewed, which is a considerably more dangerous thing.

## What happens after day 90

Two things, and both need an owner.

Monitoring for silent degradation, because that is how agents fail. Volume, cost per task, escalation rate, and median run length, checked weekly. A monthly random sample of twenty outputs, read by the person who owns the quality bar. Every quiet failure I have investigated was visible in a random sample weeks before anyone noticed.

And expansion, deliberately. Open one new case category at a time, with the same elevated review. The temptation after a successful ninety days is to widen scope quickly, and the widening is where the incidents come from, because the second wave of categories is always the harder one.

## Why the gates matter more than the plan

I want to be honest about what the gates are for. They are not primarily about quality control. They are about making stopping a legitimate outcome.

Without them, a project that should end at week 6 does not end. It gets extended, because ending feels like failure and nobody wants to be the person who says so. It absorbs another quarter, produces a mediocre deployment, and eventually gets canceled anyway with four times the money spent and a worse story attached.

With a written stop condition agreed in advance, ending at gate 2 is the plan working. The team moves to something better. The organisation learns that AI projects have honest outcomes, which makes the next one easier to fund.

That cultural effect is worth more than any single deployment. The organisations that get good at this are the ones that killed a few projects early and cheaply, not the ones that never had a project fail.

## The compressed version

Two weeks measuring and watching. Four weeks building against ugly data. Four weeks in shadow mode. Three weeks rolling out by category. A gate at each transition with a written condition under which you stop.

It is not fast, and I have stopped apologising for that. The three-week version produces a demo. The nine-month version produces a programme. Ninety days with gates produces an agent that is still running in a year, which is the only outcome that counts.

This is close to how we run our own builds, and we are happy to run it with your team rather than for them if you would rather keep it in house. Either way, [if you have a pilot that has not made it across, we should talk.](https://foundrysoft.co/services)

#### Related reading

[AI Voice Agents Answer the Phone Now. What That Actually Does to Your Support Org.

Enterprise voice agents crossed from novelty to normal this year. The technology question is largely settled. The interesting questions are what happens to your escalation path, your metrics, and the people left holding the hard calls.

AI Voice Agents Customer Support Contact Center AI

](https://foundrysoft.co/blog/voice-agents-support-org-economics)[Shadow Agents: Somebody in Your Company Has Already Built One

Over a million agents have been built in Copilot Studio alone, most of them by people who are not engineers. Shadow AI is not a hypothetical governance risk, it is the current state of most enterprises. Here is how to find them and what to do that is not a ban.

Shadow AI AI Governance Agentic AI

](https://foundrysoft.co/blog/shadow-agents-ai-governance)[What Agentic AI Actually Looks Like in Supply Chain and Manufacturing Operations

Supply chain is the function where agents have the clearest business case and the worst data. Here are the four workflows where AI agents earn their keep in manufacturing and logistics, and the two where they consistently disappoint.

Agentic AI Supply Chain Manufacturing

](https://foundrysoft.co/blog/agentic-ai-supply-chain-operations)

#### Next Article

[

AI Agents Are About to Start Buying From You. Is Your Checkout Ready?

](https://foundrysoft.co/blog/agentic-commerce-checkout-readiness)

Available for new projects

## Let's build something great.

Have a project in mind? We are an elite software and AI development studio ready to bring your ideas to production. Let's talk about your roadmap.

Start a Project [See our work](https://foundrysoft.co/work)

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "FoundrySoft",
  "url": "https://foundrysoft.co",
  "logo": "https://foundrysoft.co/logo.svg",
  "description": "FoundrySoft builds production-grade software and AI systems for US companies, from an India-based team of senior engineers.",
  "sameAs": [
    "https://github.com/foundrysofthq",
    "https://www.linkedin.com/company/foundrysoft",
    "https://www.instagram.com/foundrysoft/"
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "WebSite",
  "name": "FoundrySoft",
  "url": "https://foundrysoft.co"
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "TechArticle",
  "headline": "From AI Agent Pilot to Production in 90 Days, With the Gates in Between",
  "description": "Most agent pilots die between the demo and the deployment. This is the 90-day plan we use to get an agent into real production volume, including the four gates where the honest answer is sometimes to stop.",
  "url": "https://foundrysoft.co/blog/agent-pilot-to-production-90-days",
  "mainEntityOfPage": "https://foundrysoft.co/blog/agent-pilot-to-production-90-days",
  "image": [
    "https://foundrysoft.co/images/blog/agent-pilot-to-production-90-days.webp"
  ],
  "datePublished": "2026-08-26",
  "dateModified": "2026-08-26",
  "keywords": "AI Agent Deployment, Agentic AI, AI Implementation, Enterprise AI, Shadow Mode",
  "author": {
    "@type": "Person",
    "name": "Varun Raj Manoharan"
  },
  "publisher": {
    "@type": "Organization",
    "name": "FoundrySoft",
    "logo": {
      "@type": "ImageObject",
      "url": "https://foundrysoft.co/logo.svg"
    }
  }
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://foundrysoft.co/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://foundrysoft.co/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "From AI Agent Pilot to Production in 90 Days, With the Gates in Between",
      "item": "https://foundrysoft.co/blog/agent-pilot-to-production-90-days"
    }
  ]
}
```