01
Artifacts you can point to
A live MCP server with documented tools. Schema rendering correctly in agent inspectors. A booking endpoint an agent can actually call. Real, instrumented, working — not a deck.
Consulting · Implementation
Infrastructure Implementation
I build the agent-readiness layer your audit identified — schema, MCP server, action endpoints, operational workflows, and the analytics that prove any of it works. Modular by OARS level, so you only pay for what moves the needle.
— the problem
What this is actually for
You know the gaps. Vendor proposals are in a folder somewhere. Your engineering team has "agent stuff" on the backlog under a dozen other priorities, and every month it slips another sprint. Meanwhile the agent traffic is real, the regulatory clocks are real, and the gap between knowing what to build and shipping it is starting to feel like the whole problem.
Implementation is the part where someone actually ships. Same person from spec to ship, working inside your existing stack — not a parallel platform to maintain, not a dashboard your team has to learn. You hand off finished, instrumented infrastructure your engineers can read, run, and extend.
— outcomes
What's different when we're done
Three concrete things you walk away with.
02
Engineering you can hand off
Code in your repo, written to look like the rest of your codebase, with the runbook your on-call would actually want. No black boxes, no proprietary middleware, no lock-in.
03
A measurable baseline
Attribution wired in from day one, so six months later you can answer "is this working?" in numbers — which is the question the budget owner is going to ask.
— modules
Pick what you need, skip the rest
Five modules, priced independently.
Each module corresponds to a band of OARS levels. Most engagements start with one or two and add others over time as the agent-traffic numbers earn the next investment. Start prices below; final pricing is set in writing after a focused scope conversation.
OARS Levels 1–2
Schema & structured data
How agents find and understand your business. Schema.org markup, oars.json, robots and AI-bot directives, sitemap structure, well-known endpoints. The foundation everything else depends on. Level 0 issues — uptime, security headers, agent-blocking CAPTCHAs — are flagged separately and usually go back to your infra or DevOps team rather than landing in this module.
From $10K
OARS Level 3
MCP server
How agents actually use your business. A Model Context Protocol server exposing your capabilities — agent cards, declared tools, authentication, rate limits, audit trail. Built to your stack, deployed to your infra.
From $15K
OARS Levels 3–4
Booking & action layer
How agents close. Agent-callable endpoints for the things your customers actually do — book, quote, query, purchase. Where agent-readiness starts paying for itself in measurable conversions.
From $20K
OARS Level 5
Operational workflows
How agents help you run the business, not just sell to it. Internal agent-driven workflows for fulfillment, follow-up, scheduling, and back-office ops — with human checkpoints where they belong.
From $15K
Cross-cutting
Analytics & attribution
How you know any of this is working. Tracking which AI sources refer traffic, how agents engage, where conversions come from. The data layer everything else gets judged on, and usually the cheapest module to start with.
From $8,500
— process
How a build actually runs
From scope to shipped, per module.
Week 0
Scope
If you've done an audit (mine or someone else's), we move fast. If not, a focused scoping conversation and a fixed quote per module, before anything is signed.
Weeks 1–2
Spec
A written technical spec per module — endpoints, schemas, edge cases, rollback plan. Reviewable by your engineering team before a line of code ships, with revisions included.
Weeks 2–6
Build
I write the code. Daily pushes to a branch your team can review. Async-friendly, with sync calls scheduled around your team's cadence — not the other way around.
Week 6+
Ship + handoff
Production deploy, integration tests passing, monitoring wired in, runbook delivered. Two weeks of post-ship support included so the first 14 days of "real traffic" don't surprise anyone.
— fit
Who this is for
Good fit: Companies with an audit in hand (or willing to do one), real decision authority on the call, and the ability to move when the spec is approved. Existing engineering teams welcome — I work with them, not around them.
Not a fit: "Still exploring options" — implementation is the build phase, not the discovery phase. If you're earlier than that, the audit is the right starting point and gets you better quotes from anyone, not just me.
Pricing: most engagements land between $8,500–$75K depending on which modules and at what scope. Fixed in writing before any code ships.
— FAQ
Common questions
Questions people ask before signing a build.
Do I have to do the audit first?
Not strictly — but if you haven't, the implementation will be more expensive, because we're scoping in the dark. If you've had an audit elsewhere, share it and we'll work from that. If you haven't, the audit cost is creditable against implementation, so there's no double-spend.
Will you work with my existing engineering team or replace them?
Work with them. I'm a contractor in your stack, not a vendor selling a parallel system. Your engineers review the spec, can pair on the build if useful, and own the code after handoff. Most clients find this is the only way the implementation actually sticks.
What if we only want one module?
Fine — that's how most engagements start. Modules are priced independently. The most common starting points are Schema & structured data (foundational, fast wins) or Analytics & attribution (cheap, makes the rest measurable).
How do you decide $8,500 vs. $75K?
Module count, scope per module, and stack complexity. A single-module schema engagement on a clean modern stack is at the low end. Multi-module on a legacy or heavily-customized stack with regulated data is at the high end. The quote is fixed before work starts and doesn't move unless you change scope.
What stack do you build on?
Yours. I build in whatever language and framework your codebase already uses, deployed to your infrastructure. The MCP server, schema layer, and action endpoints are infrastructure choices we'll make together — not "you get our platform."
Who owns the code at the end?
You do. Full ownership, no licensing, no per-seat fees, no "managed service" gating. The retainer (optional) is a separate, ongoing arrangement for keeping the infrastructure healthy — not a hostage situation.
What if the OARS spec changes mid-build?
I author the spec, so I usually know about changes well before they're public. If something material shifts mid-engagement, I'll flag it, explain the impact, and either fold it into the current build or note it as a future-phase item. Same-spec-version delivery is the default.
An audit usually comes first
The build goes better when we both know the gaps.
If you've already had an audit, great — let's talk modules. If you haven't, the audit is usually worth doing first; it makes implementation meaningfully cheaper because we can skip the discovery phase, and the cost credits back against the build.
I respond personally within 1 business day. No pitch — just a real conversation.