2-Week Fixed Engagement

Your agent works.
Production doesn't.
We fix that.

You have a working prototype. Auth is half-built. Logging is console.log. Deployment is a single server you're afraid to touch. We come in, assess your setup, and deliver a production-ready agent in 2 weeks, with auth, observability, and managed hosting.

$3,000 – $7,500 · fixed price · 2 weeks · 50% upfront
What we need from you: 1-hour kickoff · repo access · 1–2 Slack replies/day · 1-hour handoff.
What happens in 2 weeksFixed scope · fixed price
Week 1: Build
Architecture review of your current agent / MCP setup
OAuth 2.0 auth, role-based access, API key management
Logging + tracing, every tool call tracked and visible
Deployment to LeanMCP managed edge infrastructure
Week 2: Harden & Hand Off
Rate limiting to protect your downstream systems
Security scan: secrets exposure, permission audit
Edge case testing and performance hardening
Documentation + 1-hour team onboarding session
By Day 14Live in production. You own it.
The real problem

The prototype took a week.
Production has taken months.

Every team hits this wall. The AI prototype works on your laptop. Getting it to actually run in production, with real auth, real monitoring, real security, is what consumes your entire roadmap.

The wall every team hits

Auth that actually works

OAuth 2.0, token rotation, RBAC, API key management. Building this properly from scratch takes 2–4 weeks. Most teams end up with a brittle homegrown solution that fails at the worst moments.

Avg. time lost: 3–4 weeks of engineering
The wall every team hits

No observability in production

Something goes wrong. An agent makes unexpected calls. A user reports broken behavior. You have no logs, no traces, no history. You're debugging blind with no way to reproduce the issue.

Avg. time lost: 1–2 weeks per incident
The wall every team hits

Deployment is still manual

Running from your laptop, a single EC2, or a Vercel function that times out on long requests. It works until it doesn't. When it breaks, there's no fallback and no visibility into what failed.

Avg. time lost: 2–3 weeks of infra work
Built for teams like these

Startup with agent in staging for 6+ weeks

The prototype was done. Auth was half-working, logging was console.log, deployment was a single EC2. Production felt permanently out of reach. Engineers kept getting pulled onto other work.

→ Sprint goal: auth + observability + managed deployment. 2 weeks. Fixed scope.

AI agency delivering MCP to clients

Building AI agents for multiple clients. Kept solving the same infra problems on every project: OAuth, rate limiting, deployment. Needed a repeatable production process, not a rebuild every time.

→ Sprint goal: reusable production stack, documented and handed off to client's team.
What's included

Everything to go from
prototype to production.

We use LeanMCP's own infrastructure, the same stack 8,000+ developers build on. You get a real production deployment built and handed off in 2 weeks.

🔍
Architecture Review
We assess your current setup and identify exactly what needs to change before touching any code. You get a written diagnosis on Day 1.
Current agent / MCP structure review
Security gap identification
Deployment path recommendation
Written findings document
🔐
Auth & Access Control
Production auth using LeanMCP's built-in OAuth 2.0 layer. Role-based access so different users get different tool permissions. No more admin-access-for-everyone.
OAuth 2.0 with Google, GitHub, etc.
RBAC, role-based tool access
API key management + rotation
Token-based authentication
📊
Observability & Logging
Every tool call logged. Latency tracked. Errors surfaced in real time. When something breaks in production, you have a full trace, not a blank screen.
Real-time tool call monitoring
Distributed tracing across requests
Structured logs with request/response
Error alerting and latency tracking
🚀
Managed Deployment
Your agent deployed to LeanMCP's edge infrastructure: 30+ regions, auto-scaling, fault-tolerant. No single server. No manual restarts. No DevOps overhead for your team.
Edge deployment, 30+ regions
Auto-scaling based on demand
Automatic failover
Built-in health monitoring
🛡️
Rate Limiting & Security
Configurable rate limits per user, per IP, per API key. Sensitive data detection. Security audit report identifying any exposure risks in your current setup.
Rate limits: per user / IP / key / global
Sensitive data detection scan
Abuse prevention configuration
Written security audit report
📄
Documentation & Handoff
Complete documentation written for your team: how it's deployed, how to manage it, how to extend it. Your team fully owns what we build. No dependency on us after handoff.
Architecture documentation
Operations runbook
1-hour team onboarding session
30-day bug fix warranty
Deliverable
Details
Included
Production deployment
Live on LeanMCP managed edge infra, globally available
✓ Included
OAuth + RBAC auth
Enterprise auth, API key management, role-based access
✓ Included
Observability dashboard
Real-time logs, traces, latency metrics, error alerts
✓ Included
Rate limiting
Configured to protect your downstream systems
✓ Included
Security audit report
Written findings: secrets exposure, permissions, vulnerabilities
✓ Included
Architecture docs + runbook
Full written documentation for your team
✓ Included
Team onboarding session
1-hour walkthrough. Your team is fully independent after.
✓ Included
30-day bug fix warranty
If something we built breaks in the first 30 days, we fix it
✓ Included
What we need from you

The most common question before engaging: "How much of my team's time will this take?" Here's exactly what we need, and what we don't.

📞

1-hour kickoff call

Day 1. We walk through your current setup and agree on scope. You tell us what the agent does and where it's stuck.

🔑

Repository access

Read access to your codebase. We need to see the current agent implementation. Write access only for deployment config.

💬

1–2 Slack replies/day

We'll ask questions as they come up. Typically 2–5 minutes of your time per day during the sprint. No need to be available full-time.

1-hour handoff session

Day 14. We walk your team through everything we built. After this, your team is fully independent.

That's it. Your engineers don't need to block their calendars. We flag decisions within the same day. No waiting. If unexpected complexity comes up, we surface it immediately, not at Day 14.
The timeline

Day by day.
No surprises.

We've mapped this process precisely. Here's exactly what happens, when.

Week 1: Build
Day 1
Kickoff call (1 hour)
We walk through your setup. You describe what the agent does, what systems it touches, where it's broken. We ask specific questions. We agree on scope.
Output: written assessment + agreed scope
Day 2–4
Auth + observability
We implement OAuth using LeanMCP's built-in auth layer, configure RBAC for your specific use case, and connect the observability stack so every tool call is logged and traced.
Output: auth working + logs flowing in dashboard
Day 5–6
Deploy to managed infra
Your agent goes live on LeanMCP's edge infrastructure. Auto-scaling on. Health checks on. You can see it running in the dashboard from your browser.
Output: live deployment URL, dashboard access granted
Day 7
Week 1 review (30 min)
You test the deployment. We walk through the logs together. You flag anything to adjust before we harden in Week 2.
Output: your sign-off on Week 1 work
Week 2: Harden & Hand Off
Day 8–9
Rate limiting + security audit
We configure rate limits to protect your downstream systems. We run a security scan, checking for secrets exposure, permission gaps, and common MCP vulnerabilities. You get the written report.
Output: security report + rate limits configured
Day 10–11
Edge cases + hardening
We stress-test, handle error cases your agent hasn't seen yet, and ensure graceful degradation when upstream services are slow or unavailable.
Output: hardened deployment, edge cases handled
Day 12–13
Documentation
We write your architecture docs, runbook, and team onboarding materials, specific to what you built, not generic templates.
Output: documentation package delivered
Day 14
Handoff (1 hour)
We walk your team through everything: the deployment, the dashboard, how to read logs, how to extend what we built. You fully own it after this call. 30-day bug fix warranty begins.
Output: your team fully independent · warranty active
Who this is for

You have something working.
Production is the bottleneck.

Not for teams at the idea stage. For teams with a working agent or MCP stuck at the production wall.

Best fit

Startup with working AI prototype

Agent or MCP works locally or in staging
Need to ship to production this month, not next quarter
Don't want to spend 6 more weeks on infra plumbing
CTO or AI engineer can give us 2 hours across the 2 weeks
Best fit

AI agency building for clients

Building AI products for multiple clients repeatedly
Need a repeatable, professional production process
Want to deliver with real observability, not just a prototype
Interested in using LeanMCP's stack on future projects
Good fit

SaaS team adding AI features

Product has a working API, want agents on top of it
Engineers building but hitting the auth/deployment wall
CTO needs to deliver AI features without derailing the roadmap
Not a fit yet

Large enterprise / Fortune 500

Procurement cycle 3–6 months, legal review, compliance docs required
We don't have enterprise references yet. We'll be honest about this.
Come back in 6 months. By then we will.
After the sprint, optional next steps

Most clients continue with one of these. All optional. You fully own what we build regardless.

Managed hosting

$299 – $799 / month
We keep your deployment running: monitoring, updates, protocol changes, uptime. You focus on your product.

Platform access

$29 – $99 / month
Self-serve access to LeanMCP's full platform. Your team manages deployments and observability independently.

Ongoing retainer

Custom
For teams shipping frequently. Available for new agent builds, extensions, or production incidents. Flexible scope.
Pricing

$5,000 fixed.
vs. months of lost engineering time.

Every task in the sprint is something you'd have to build yourself. Here's what that actually costs, in real engineering hours at a conservative $150/hr.

What gets built
Build it yourself
Sprint price
OAuth 2.0 + RBAC auth
3–4 wks · ~$18,000
✓ included
Observability + logging + tracing
1–2 wks · ~$9,000
✓ included
Managed edge deployment (30+ regions)
2–3 wks · ~$13,500
✓ included
Rate limiting + security audit
1 wk · ~$6,000
✓ included
Docs, runbook, team onboarding
3–5 days · ~$4,500
✓ included
Total
7–11 weeks · ~$51,000
$3,000 – $5,000
Payment: 50% upfront, 50% at Day 14 handoff. We take half upfront because we're confident in the scope we agreed. You hold the other half until you're satisfied with what was delivered. Fixed price means fixed price. No invoice surprises at the end.
Simpler setups
Basic Sprint
$3,000
One agent · One system · 2 weeks
1 MCP server / agent deployment
Connect 1 internal system or API
Auth + rate limiting
Basic observability dashboard
Architecture documentation
30-day bug fix warranty
Book a call →
Complex setups
Extended Sprint
$7,500+
Multi-agent · Complex integrations
Multi-agent orchestration
5+ system integrations
Custom auth (Okta, Azure AD)
Multi-tenant deployment
Compliance documentation
Book a call →
After the sprint (optional, no lock-in)
Managed hosting
$299 – $799 / month
We keep your deployment running. Monitoring, updates, uptime. You focus on your product.
Platform access
$29 – $99 / month
Self-serve access to LeanMCP's full platform. Your team manages everything independently.
Ongoing retainer
Custom
New agents, extensions, incidents. Flexible scope for teams shipping frequently.
Common questions

Honest answers.

What do we need to have ready before we start?
A working prototype, something that runs and does something, even if only locally. We need access to your codebase and an engineer who can answer questions async during the sprint. You don't need deployment figured out. That's what we handle.
Do we have to use LeanMCP after the sprint?
No. The agent and code belong to you entirely. The documentation we write covers how to operate it independently, on our platform, on your own AWS, or anywhere else. There's no lock-in. We build on LeanMCP's infra because it's the fastest path to a production-grade setup, not because it traps you.
What if our agent is more complex than expected?
We define scope in the kickoff call before work begins. If we discover additional complexity during the sprint, we tell you immediately, not at Day 14. For genuinely complex setups, we recommend the Extended Sprint pricing upfront rather than surprising you later. Fixed price means fixed price.
What languages and frameworks do you work with?
TypeScript and Python, the two languages LeanMCP's SDK natively supports. For agents using LangChain, LangGraph, OpenAI Agents SDK, or custom implementations, we can work with those as long as the core logic is in TypeScript or Python.
How does payment work?
50% upfront to start the sprint, 50% at the Day 14 handoff. We use Stripe. A payment link is all you need. For teams that need net-30 or a formal SOW for procurement, we can accommodate that on request, just mention it on the call.
Have you done this before?
We've built the LeanMCP platform itself, including deploying our own AI agent (the LeanMCP support bot) to production in 2 hours using this exact stack. The sprint is the same process we use internally, productized as a service. We're early. We'll be honest if your use case is outside what we've tested.

Ready to stop fighting
your own infrastructure?

20-minute call. You tell us where you're stuck. We tell you exactly what the sprint covers and what it costs for your specific setup. If it's not a fit, we'll say so.

Lu Xian · Dheeraj Pai · Co-founders · leanmcp.com