A field methodology

The Easton Way.

How we build AI agents that get installed, used, and paid back. Eight phases. Two hard gates. Ninety-three steps. The operating discipline behind every Easton build.

8
Phases per agent
2
Hard gates that block the next step
93
Checklist items run on every build
The methodology, at a glance

From discovery to retro, in roughly forty-eight hours of work and two weeks of stabilization.

  1. 01Discovery & SpecHard gate
  2. 02Architecture & Credentials
  3. 03Build
  4. 04Internal QA
  5. 05Client UATHard gate
  6. 06Deploy & Handoff
  7. 07Stabilization
  8. 08Closeout & Retro
01

Discovery & Spec Hard gate

~6 hours · blocks Build until client sign-off

The first phase has one job: produce a written PRD the client signs off before any code gets written. No PRD, no Build. It's the cheapest place to catch a misunderstanding, and the most expensive place to discover one is week three.

Easton interviews the SME who owns the workflow, maps it step by step, and collects five to ten golden examples (real input, real expected output) so QA later has a fixed bar to test against.

Key outputs
  • Signed PRD attached to the project
  • Golden examples + process map
  • Hours and expected monthly cost
What you bring
  • One hour with the workflow owner
  • A handful of real examples
  • Sign-off authority on the spec
PRD · Lewis × Document Intake Agent
LSJ-001
Goal
Trigger
Inputs
Outputs
Success
Out of scope
Signed
02

Architecture & Credentials

~4 hours · prep work before the build starts

Four hours go into the boring decisions that wreck projects when they're skipped. We pick specific tools inside the chosen category, draw the agent flow, and request every credential and API key formally so nothing dies in a Slack DM.

Token cost gets estimated against the golden set so the expected monthly run cost is grounded in maths, not vibes. Cost alerts get wired before a single line of agent code ships.

Key outputs
  • Agent flow diagram
  • Credential vault + dev environment
  • Cost alerts + token estimate
What you bring
  • API credentials
  • An IT contact for access requests
  • Confirmation of off-limits platforms
Source
Agent
Output
Credentials
OPENAI_API_KEY
GMAIL_OAUTH
SHEETS_TOKEN
03

Build

~20 hours · only starts once Phase 1 is signed off

The part most agencies sell as the whole project. At Easton it's roughly forty percent of the work, and it never starts without a signed PRD upstream.

Happy path first, tested against golden examples. Error handling, retries, and structured logs are first-class citizens, not afterthoughts. Hours get logged daily so a budget overrun shows up while there's still time to do something about it.

Key outputs
  • Working agent against golden set
  • Integrations wired + trigger live
  • Structured logs and retries
What you bring
  • An SME on call for prompt iteration
  • Sign-off on small in-scope tweaks
agent.py
1# intake handler
2def process(doc):
3 result = extract(doc)
4 validate(result)
5 return result
Tests · 5 of 5 passing
04

Internal QA

~8 hours · everything Easton can break before the client sees it

Before the client opens the agent, we break it. Network pulled. Bad input shoved in. Auth tokens expired. Rate limits pushed. A 100-run load test confirms cost per run lines up with the estimate.

Client UAT doesn't open until zero P0/P1 bugs are outstanding. Anything looser turns UAT into bug triage instead of the trust-building session it's supposed to be.

Key outputs
  • Every golden example + edge case passes
  • Cost-per-run measured at 100× load
  • Zero P0/P1 bugs at UAT opening
What you bring
  • Nothing. Easton runs this without client time.
Edge cases · 5 of 5
empty_inputPass
malformed_docPass
auth_expiredPass
rate_limit_hitPass
network_dropPass
Load test 100×0.18s avg
05

Client UAT Hard gate

~6 hours · blocks Deploy until written sign-off

The agent stands up in staging. You get a live walkthrough, run your own tests against real data, and mark each success criterion pass or fail on the spot.

Production deploy doesn't happen without written sign-off. If sign-off is blocked, the blocker gets named in writing and the project sits in UAT until it's cleared. No silent slips into prod.

Key outputs
  • Live walkthrough recording
  • Pass/fail per success criterion
  • Written client sign-off
What you bring
  • The people who'll actually use the agent
  • Real data to throw at it
  • A decision-maker who can sign off
Success criteria · UAT
5 of 5
Accuracy ≥ 95% on golden setPass
Latency < 5s p95Pass
Cost ≤ $40/mo at volumePass
Alerts route to SlackPass
Runbook draftedPass
Signed off · Client2026-05-18
06

Deploy & Handoff

~4 hours · only starts once Phase 5 is signed off

Deploy is fast because the work behind it is done. Production goes live, failure alerts get wired to you and Easton, and a forced test failure confirms the alert actually fires before anyone relies on it.

A 10–15 minute Loom walkthrough plus a one-page runbook ship the same day. Optional 30-minute Q&A if the build warrants one. Nobody disappears.

Key outputs
  • Production-deployed agent
  • Failure alerts wired and tested
  • Loom walkthrough + runbook PDF
What you bring
  • A nominated owner on your side
  • Thirty minutes for the handoff Q&A
Deploying to production 100%
Live
Loom walkthrough
Runbook · 1 page PDF
Failure alerts wired
07

Stabilization

2 weeks · bug-only window, included in the price

The two weeks after deploy are where most projects quietly go sideways elsewhere. We scope that window into every build. Logs reviewed daily for the first three days, weekly thereafter. Every alert triaged the same day.

Bug-fixes only. Feature requests get captured as new project candidates and quoted properly, so the live agent stays stable.

Key outputs
  • Daily log review days 1–3
  • Actual vs estimated cost on day 7
  • Quoted follow-on list for deferred features
What you bring
  • Honest feedback if something looks off
  • An alert-forwarding contact
Stabilization log Day 14 / 14
09:02OKDaily run complete · 42 docs
09:14INFOCost vs estimate · −12%
11:48OKWebhook latency · 0.31s
17:00OKEnd of day · zero P0/P1
7 days clear · stabilization closing
08

Closeout & Retro

~3 hours · locks the project and feeds the next one

The final phase locks hours, profitability, and learnings. The internal retro names what was estimated vs actual, what broke, and what's worth lifting into the pattern library for the next build.

Skipping this is how an agency forgets what blew up and repeats it on the next project. Easton runs it on every build, every time.

Key outputs
  • Hours and profitability locked
  • Internal retro doc
  • Retainer proposal where eligible
What you bring
  • Honest final satisfaction check
Retro · final numbers
Hours
47
Profit margin
62%
Cost · actual
$36/mo
Satisfaction
9 / 10
The two hard gates

Two structural rules that make the difference between an install and a demo.

Most of the eight phases are visual order. Two of them are non-negotiable. These gates protect every build from the common patterns that kill AI projects elsewhere.

Gate 1 · Discovery blocks Build

No code gets written before the PRD is signed.

A 90-minute conversation in week one is worth a 90-hour rewrite in week six. We won't move into Build until the PRD has named the goal, inputs, outputs, success criteria, and the out-of-scope list, and the client has signed off in writing.

Gate 2 · UAT blocks Deploy

Nothing goes to production without written client sign-off.

An agent that demos well in staging isn't an installed system. We hold production deploy until the client has run the agent against real data, marked every success criterion pass or fail, and confirmed in writing they're ready to go live.

Run your next AI project through the Easton Way.

Book a 30-minute discovery call. You'll leave with a scoping note inside 48 hours that names the agent, the build hours, and the expected monthly running cost.