Six months of running AI agents inside our own business taught us what the demo never shows you.
From £4,000 for a standalone AI Readiness Assessment. £20,000–£40,000 for a full inception-to-production engagement.
Graph Digital provides AI agent development services for complex B2B businesses. We design, build, and operate production-grade AI agents, from architecture scoping through deployment, using the same standards we apply in our own live systems. For complex B2B organisations ready to commission a serious build, that distinction matters more than anything else on this page.
Why most AI agent builds fail before the business trusts them
There is a specific moment when AI agent development goes wrong. It is not when the agent produces a bad output. It is when the business realises, weeks or months after deployment, that the system was never designed for the conditions it is now operating in.
Three failure patterns appear consistently in production environments.
Context windows fill and the agent loses the thread. Complex operational workflows generate more tokens than controlled demos ever do. Every tool call, every retrieved document, every system handoff adds to the window. An agent that performs cleanly in a structured test runs out of context in a real multi-step task and fails without warning. This is not a model limitation. It is an architecture decision that was never made.
Memory resets between sessions. An agent that cannot recall what it decided, escalated, or left incomplete in a previous session is not useful for any operational workflow that spans more than one conversation. Persistent state and memory architecture are not features you add after the build. They are designed in or they are absent.
Edge cases reveal what the happy path conceals. A demo runs on the well-structured input the developer prepared. A production workflow encounters partial data, unexpected inputs, mid-task state changes, and exceptions that no one thought to test. Agents built to pass the demo fail the first time a real edge case arrives.
These are not model failures. They are architecture failures: they are only visible in production.
The commercial cost is specific: a business that chooses the wrong development partner pays once for the build that does not survive production, and again for the 12–18 months of delay, eroded confidence, and rebuild budget that follows. The wrong partner costs you twice.
That is why Graph Digital builds AI agent development services to the standard we apply in our own production systems. Not as a marketing claim, but as the source of every architecture decision we make on client work.
What six months of running AI agents in our own business actually teaches you
We run AI agents inside Graph Digital's own financial and operational processes. Not as a sandbox experiment. As live systems with real stakes and no human in the execution loop. That operational reality is where our AI agent development services come from.
The CLI-over-MCP decision is the clearest example. Most AI agent development companies recommend MCP (Model Context Protocol) tooling as the standard approach. In controlled environments, MCPs perform cleanly. In production, they impose a context tax: every MCP call adds tokens to the window. In complex multi-step workflows, the window fills before the task completes. The agent loses coherence. We switched to CLI wrappers: JSON in, JSON out. Faster execution, more controllable behaviour, no context overhead. This is not a theoretical position. It is what six months of running agents in our own operations produced.
Memory architecture taught us the same lesson. Agents that persist state correctly — knowing what they decided three days ago, what they escalated, and where a workflow left off — require explicit memory design that is not visible in a demo. It is only visible when the agent is asked to resume a workflow it started earlier and the output must be consistent with prior decisions.
Fallback logic is the third area where production diverges from demo. A production AI agent needs defined guardrails: what it does not decide alone, specific escalation triggers, a path to a human when confidence is low, and an audit trail. These are not optional refinements. They are the conditions under which a business will actually trust the agent with real operational work.
Graph Digital's AI agent development services are built on these production findings, not on reference architectures or whitepaper frameworks.
Proof: what our own operations look like
The most credible proof we can offer is our own business.
Financial reconciliation agents
Graph Digital built a multi-agent system connecting three operational systems: CRM, project management, and finance. The agents query each system, run reconciliation, identify discrepancies, escalate exceptions via Slack, and generate reports without any human in the execution loop. Built in one day. Six months of continuous operation without a failure requiring intervention. The system replaced a five-figure bridging SaaS tool. We know exactly where it would fail, because we built every part of it and operate it ourselves.
Katelyn — Graph Digital's production agentic AI platform
Katelyn is Graph Digital's own agentic AI platform, built on the same architecture standards we apply to client work. CQRS pattern, speculative execution, sub-100ms intent classification. Operating in production for six months, with architecture publicly documented at graph.digital/katelyn.
Victrex
Victrex, a FTSE 100 advanced materials manufacturer, deployed a customer-facing technical services agent from idea to production in under six weeks.
For AI agent development services beyond these examples, we do not have named client AI agent deployments beyond Victrex. Our proof basis is our own production operations and the architectural depth with which we can describe every decision inside them. A partner who operates agents in their own business has skin in the game. A partner who only builds for clients can blame NDA for the silence.
Three phases from readiness to production deployment
Not every organisation is ready to build an AI agent. One of the most commercially valuable things a development partner can do is tell a client they are not ready, and explain what needs to change before build begins. A partner incentivised to start building immediately has no reason to give that assessment honestly.
Our AI agent development services run in three structured phases. Each phase ends with a defined gate deliverable. The next phase does not begin until the gate clears.
Phase 1 — AI Readiness Assessment
Duration: 1–2 weeks Investment: £4,000–£8,000 Available as a standalone engagement
Before any code is written, we test whether your use case, data, and workflows are ready for a production agent build. Phase 1 exists to surface the blockers that would cause a build to fail, before budget is committed to a build scope.
Phase 1 covers:
- Map the identified use case against production requirements
- Assess workflow clarity: is the process defined with enough precision to build into?
- Assess data readiness: what is available, accessible, and consistent enough to use?
- Identify integration constraints: which systems need to connect and how?
- Review ownership: is there a named accountable owner on the client side?
- Flag blockers: what must be resolved before build begins?
You receive at the end of Phase 1:
- Written readiness assessment with a traffic-light readiness view: ready, needs work, or not ready
- Identified blockers with remediation paths
- Confirmed use case recommendation, or a reframe if the original scope needs adjusting
- Go/no-go recommendation for Phase 2
Phase 1 may conclude that you are not yet ready to build. You receive the assessment, the blockers, and the remediation path. An assessment that always recommends building is not an assessment.
Once Phase 1 confirms readiness, Phase 2 converts that confirmation into a production-grade architecture, not a framework deck.
Phase 2 — Lean inception and agent architecture
Duration: 2–4 weeks Investment: £8,000–£12,000 Requires Phase 1 completion or equivalent readiness evidence
Phase 2 converts the approved use case into a concrete design for production deployment. This is where AI agent development services take shape: from approved concept to production-ready architecture.
Phase 2 covers:
- Define agent scope and task boundaries: what it will and will not do
- Map tool access and permissions: what systems it can read, write, and act on
- Design the state and memory model: what the agent remembers, what it forgets, and why
- Define fallback and escalation logic
- Architecture specification: CQRS pattern, speculative execution, intent classification
- Integration design: named systems, API contracts, data access model
- Observability and governance: logging, auditability, security model
- Handoff and escalation design: when and how the agent routes to a human
You receive at the end of Phase 2:
- Production-grade architecture document, not a sketch or methodology deck
- Integration map and dependency register
- Governance and permissions model
- Confirmed build scope and sprint plan for Phase 3
Phase 3 — Agent build and production deployment
Duration: 4–8 weeks Investment: £12,000–£20,000 Requires Phase 2 completion
Phase 3 delivers the first working, production-grade agent into live operations.
Phase 3 covers:
- Build by senior engineers: no junior team inherited after scoping
- Architecture standards applied throughout: CLI-over-MCP wrappers, CQRS pattern, speculative execution, the same standards used in Katelyn and in Graph Digital's own financial reconciliation agents
- Sprint delivery against confirmed Phase 2 architecture
- Failure mode testing and edge case validation before live deployment
- Production deployment with monitoring and observability
- Handoff with documentation and a defined support model
You receive at the end of Phase 3:
- A production-deployed AI agent, not a sandbox prototype
- Monitoring and observability setup
- Architecture, integration, and operational documentation
- Defined support and maintenance model
- Post-deployment review and iteration backlog
Full engagement summary
| Phase | Duration | Investment |
|---|---|---|
| Phase 1 — AI Readiness Assessment | 1–2 weeks | £4,000–£8,000 |
| Phase 2 — Inception and Architecture | 2–4 weeks | £8,000–£12,000 |
| Phase 3 — Build and Production Deployment | 4–8 weeks | £12,000–£20,000 |
| Full engagement (all three phases) | 7–14 weeks | £20,000–£40,000 |
Mid-market consultancy AI pilot programmes typically quote £50,000–£150,000 or more for initial engagements. Graph Digital delivers to production standard at a fraction of that cost: senior engineers throughout, architecture standards from live systems, no large team running a methodology.
For multi-agent systems with complex enterprise integrations, Phase 3 scope may exceed the ranges above. This is assessed and confirmed during Phase 2. There are no open-ended scope expansions after a phase gate is passed.
Is this right for you?
- You have a real, identified use case: a specific operational bottleneck, not an abstract AI agenda
- You are ready to confront process and data readiness before build begins
- Your budget is aligned to the £20,000–£40,000 range for a production-grade engagement
- You are in a complex B2B sector: industrial, manufacturing, financial services, or professional services
- Your CTO or technical lead will be involved: you want architecture accountability, not a black box
- You want a production-deployed system, not a proof-of-concept for internal demonstration
- You want to start with a low-commitment readiness assessment (£4,000–£8,000) before committing to a full engagement: Phase 1 is available as a standalone
When is this not the right fit?
- You are still deciding whether AI is relevant to your business: you need advisory orientation first
- You need a low-cost proof-of-concept to demonstrate concept to internal stakeholders
- You need an 18-month enterprise transformation programme with a large delivery team
- Your use case is consumer-facing or SaaS: our expertise is complex B2B operational contexts
Frequently asked questions
What does Phase 1 deliver, and what does it cost?
Phase 1 is a 1–2 week assessment priced at £4,000–£8,000, available as a standalone engagement. We map your use case against production requirements, test workflow and data readiness, identify integration constraints, and flag the blockers that would cause a build to fail. You receive a written readiness assessment with traffic-light ratings, a list of identified blockers with remediation paths, a use case recommendation or reframe where needed, and a go/no-go recommendation for Phase 2. If Phase 1 concludes you are not ready to build, you receive that finding and the path to readiness, not a push into Phase 2.
How does procurement work — do you issue a statement of work?
Yes. Each phase is covered by a statement of work with defined scope, deliverables, timeline, and fee. Payment is typically 50% at project start and 50% on delivery of the phase gate deliverable. For clients with quarterly billing requirements, we can discuss alternative arrangements during the scoping conversation.
We have an existing AI agent build that is not working. Where do we start?
If you have an agent build that is underperforming or stalled, contact us and we will identify the right entry point for your situation.
How is Graph Digital different from a general AI consultancy or systems integrator?
The difference is proof basis and architecture standard. A general AI consultancy builds to demo quality, the standard that wins pitches. Graph Digital builds to the standard we apply in our own live systems, where demo quality fails within weeks. The CLI-over-MCP finding is one example: a consultancy optimising for demo performance recommends MCPs. A practitioner who has debugged a context window collapse in a live system uses CLI wrappers instead. Our recommendations come from operating production agents, not from reading reference architectures.
Start with the readiness assessment
The AI Readiness Assessment is the right starting point for most engagements, not because it generates revenue, but because most businesses discover something material about their readiness that changes the build scope.
Some clients proceed directly to Phase 2 after Phase 1. Some complete readiness work first. Some discover the right answer is a different solution type. All of these are good outcomes from an honest assessment.
The cost of the wrong development partner is not limited to the development fee. It includes the delay, the eroded confidence in future AI investment, and the rebuild. A build that fails in production because context management was never designed, memory never persists, and the first real edge case breaks the agent costs far more than the original engagement.
Request your AI readiness scope: 30-minute scoping conversation with Stefan Finch. From £4,000.
Not ready to commission a build? See how we built a finance reconciliation agent in one day: the architecture decisions, the failure modes we encountered, and what six months of running it without intervention taught us about what production-grade actually means.