Skip to content

Engineering Path · Detail

The five-phase Embed Method

Diagnostic, Architect, Build & Train, Embed, Operate. The same five phases we use with our own clients to take AI roles from one written diagnosis to your team running production agents.

This page is the long form. If you're a CTO or CDO trying to decide whether to engineer with us or coach your team to engineer their own, here's exactly how the work splits, what gets produced at each gate, and what stays customer-side. No slides, no demos. Just the schematic of the engagement, written out.

Diagnostic

1 sessionFree

Phase 0 exists to tell you whether AI is even the right tool for the work you're trying to compress. One session, one written diagnosis, no procurement. We map your stack, your team's pain, and the workflows where the calendar bleeds the most. The deliverable is a four-page document you own: your stack as a fragmentation map, the top three workflows that are ready for an AI role today, and an indicative phase-aligned plan. We do this without a CDO, a data lake, or an AI roadmap. The point is the document, not the meeting; if Phase 0 says don't go, we say so in writing.

Artifact

A 4-page written diagnosis you own.

Decision gate

You sign off before Phase 1 starts.

How the room splits

We do
Run the diagnostic, write the document, name the candidates, anchor the phase plan.
You do
Bring the right two or three people to one call. Tell us where the calendar is bleeding.

Architect

2–4 weeksFixed fee

Phase 1 turns the diagnosis into a buildable blueprint. Two to four weeks of architecture work, fixed fee, signed off across every department the agents will touch (not just the sponsor). We design the agent, its read/write contract with each tool, the data path it follows, and the human decision points it hands back. The blueprint names every integration, every prompt boundary, and every escalation path. It is the document your CTO can read, your security lead can question, and your operators can recognise. Build & Train doesn't start until the blueprint is approved across stakeholders, because every shortcut taken here costs five times in Phase 2.

Artifact

A multi-department blueprint signed off across stakeholders.

Decision gate

You approve the blueprint before Build & Train begins.

How the room splits

We do
Architect the agent, define the contract, write the blueprint, run cross-department review sessions.
You do
Put the right stakeholders in the room. Approve the blueprint before we start building.

Build & Train

4–8 weeksFixed fee

Phase 2 is where the agent gets built and your team learns to operate it. Four to eight weeks, fixed fee, working in your stack (not a sandbox). We build the agent against the approved blueprint, wire it into the tools you already run, and put it in beta with a defined operator pool. In parallel, we train those operators: how to brief the agent, how to read its outputs, when to override, how to log a defect. By the end of the phase you have a working agent and a team of trained operators who can run it. We measure what we can measure, but the gate is operator confidence, not a synthetic benchmark.

Artifact

Beta agents running in your stack, your team trained to operate them.

Decision gate

Beta sign-off before the Embed phase begins.

How the room splits

We do
Engineer the agent in your stack. Train your operator pool. Set up the runbook and the audit log.
You do
Name the operator pool early. Free up time for training. Sign off on the beta when the operators say it's ready.

Embed

2–4 weeksFixed fee

Phase 3 takes the beta agent into production and hands you the keys. Two to four weeks, fixed fee. We move the agent from the beta operator pool to your production users, write the runbook your team will actually use, and stand up the audit log so you can see what the agent did and why. By the end of Phase 3 your team operates the agent day-to-day; we step back to a support posture. The handover is a document, not a verbal one. It includes the runbook, escalation paths, decision audit log, and the contract with the systems it touches. If something is missing from that document, it doesn't ship.

Artifact

Agents live in production, runbook handed over.

Decision gate

Production sign-off before Operate begins.

How the room splits

We do
Move the agent to production. Write the runbook. Hand over the audit log. Train the operations lead.
You do
Approve the production cutover. Take over day-to-day operation. Own the runbook in your repo.

Operate

OngoingSubscription

Phase 4 is the long tail. It is the part most agencies skip. Subscription, ongoing, with a quarterly review. We monitor the agent, optimise it as your stack and operators evolve, and add new agents when the diagnosis surfaces them. The agreement is renewed at quarterly review based on what's still earning its keep. In our experience, the 9-in-10 enterprise AI projects that fail in pilot fail here, because nobody owns the maintenance once the consultants leave. Operate is built into the engagement so your team doesn't have to choose between running the system and running the business, and so we keep skin in the game past go-live.

Artifact

Always-on monitoring, monthly optimization, new agents on demand.

Decision gate

Quarterly review and renewal.

How the room splits

We do
Always-on monitoring. Monthly optimisation. New agents on demand. Quarterly review of what's earning its keep.
You do
Operate the agents day-to-day. Flag what's breaking. Decide what to renew, replace, or retire each quarter.

Topology

What runs where, and who runs it

Three deployment surfaces, drawn out so a security review can happen on the page. Your data and identity stay yours. The agent layer is what we engineer and hand over. Operations is where Phase 3 lands and Phase 4 lives.

01

Your stack

Stays customer-side. You own it before the engagement and after.

  • Identity provider
  • CRM
  • ERP / finance
  • Data warehouse
  • Collaboration / docs
  • File storage

02

Brixon agent layer

Engineered during Build & Train, handed over at Embed, supported under Operate.

  • Agent orchestration runtime
  • Agent definitions + prompts
  • Observability + audit log
  • Runbook + escalation paths
  • Read/write contracts per tool

03

Operations

Who runs what after handoff. Your team operates; we support.

  • Trained operator pool runs day-to-day
  • Quarterly review with us
  • New agents on demand
  • Your runbook lives in your repo
  • Your data stays yours
  • Data stays in customer storage
  • Identity stays customer-side
  • Runtime hand-over options documented in your runbook

Technical posture

How we decide what runs where

Four operating principles. We surface them on this page so your security and architecture team can do their pre-read here, not in a discovery call.

01

Model-agnostic by default

We pick model providers per agent based on cost, latency, and compliance fit. You retain final say on which providers run in your stack; we change them when the constraints change. Bring your own keys when you want the billing relationship and audit log on your side.

02

EU-first where compliance demands it

EU regions are the default for any workload that touches PII or contractual data. Other regions only when latency or cost makes a documented case. The choice gets recorded in your runbook.

03

Self-hosted models supported on request

If a regulated workload requires on-prem or private-tenant model hosting, we engineer for it. Default agents run against managed APIs; private-tenant or self-hosted is a Phase 1 architecture decision.

04

Agent definitions live in your repo

From Embed phase forward, every agent definition, prompt, and integration contract is checked into your git org. Versioned, reviewable, rollback-able. Your team owns the code.

Lock-in posture

What you keep if you cancel Operate

The Operate phase is a subscription. If you renew, monitoring continues; if you don't, here's exactly what stays with you and what stops.

You keep

  • Agent definitions and prompts (in your git org)
  • Integration contracts (read/write per tool)
  • Runbook + escalation paths (in your repo)
  • Decision audit log (your historical record)
  • All historical agent outputs in your storage

What stops

  • Our always-on monitoring
  • Monthly optimisation passes
  • Net-new agent engineering on demand

Your agent definitions, integration contracts, and runbook stay yours. Your data stays in your stack. Runtime hand-over options (migrate orchestration to your infrastructure or keep our managed plane on your terms) are documented in your runbook. Renewals happen because the work is good. Leaving is documented and supported.

Hire your first AI role.
Start with a Diagnostic.

No pitch. Phase 0 maps your stack and where your team is losing the most time, then sends a written diagnosis: which AI role to build first, where it lives in your stack, and what your team needs to operate it. Indicative numbers shared in your Diagnostic. You own the document either way.

Book a Diagnostic Call

Reply in 24h · First call in 48h · Diagnosis in 7 days · No obligation

Brixon AI agent rendering, waving and holding a diagnostic case