> services
AI agent development services
Senior AI agent development on the Claude Agent SDK and MCP. Start with a fixed-fee discovery sprint, then a production slice in 2 to 4 weeks.
AI agent development services
We design and ship production AI agents for teams that need software to act on a workflow, not only describe it. Rhode Labs is a small, senior studio built in Brooklyn and deployed everywhere, focused on the Claude Agent SDK and Model Context Protocol (MCP). The outcome of a first engagement is one working agent in production in 2 to 4 weeks, wired to the tools your team already uses.
What’s included
- A fixed-fee discovery sprint that defines the agent’s job, its tools, and its limits before any build commitment.
- Agent architecture on the Claude Agent SDK: the agent loop, context management, subagents where they help, and compaction so the agent does not run out of context mid-task.
- Tool access through MCP servers, so the agent can read and write to your real systems (databases, internal APIs, GitHub, Slack, ticketing) under a permission model you control.
- Custom in-process tools for the actions MCP does not cover, defined with the SDK rather than bolted on.
- Verification built in: rules-based checks, validation constraints, and human approval steps for actions that change data.
- A production deployment of one thin slice, plus the runbook and observability to operate it.
A framework for scoping agent work: the action ladder
Generic “AI agent” pitches collapse very different problems into one word. The real cost driver is rarely the model. It is how far up the action ladder the agent has to climb, and how reversible each rung is. We use this table during discovery to scope honestly.
| Rung | What the agent does | Tool access needed | Risk if wrong | Typical first slice |
|---|---|---|---|---|
| 1. Read and answer | Retrieves context, summarizes, drafts | Read-only MCP (search, fetch, file system) | Low, output is reviewed | A grounded answer agent over your docs or codebase |
| 2. Suggest and stage | Proposes an action, a human applies it | Read MCP plus draft creation | Low, nothing ships unattended | A draft pull request or a staged reply held for review |
| 3. Act with approval | Executes after an explicit human yes | Write MCP behind a permission gate | Medium, gated by approval | A scoped write with a confirmation step in the loop |
| 4. Act autonomously | Completes a defined task end to end | Write MCP plus verification tools | Higher, needs strong checks | One narrow, reversible task with rules-based verification |
Most teams want rung 4 and should start at rung 2 or 3. We build the first production slice one rung below where it feels comfortable, prove the verification works, then move up. This is where MCP and the SDK earn their place. Tool permissions are explicit, and you decide which servers an agent may call.
Why the Claude Agent SDK and MCP are the differentiator
A generic AI dev shop writes the agent loop by hand: retry logic, context window management, tool dispatch, session state. The Claude Agent SDK gives us those out of the box, because it is the same loop and context engine that powers Claude Code, programmable in Python and TypeScript (Anthropic engineering). Our time then goes into your tools and your guardrails instead of into rebuilding infrastructure.
MCP handles the other half. It is an open standard for connecting an agent to external tools, databases, and services, which removes the N-by-M problem of writing a bespoke connector for every API and model pair (Agent SDK docs). We connect existing MCP servers over stdio or HTTP, and write custom in-process servers for the actions that are specific to your business. The agent gets a clean, permissioned set of tools, and you get an audit trail of what it can touch.
How an engagement works
The process is deliberately short. Weeks, not quarters.
- Discovery (fixed fee, about one week). We pick one agent worth building, map the tools it needs, place it on the action ladder, and write down what “done” looks like and how the agent will verify its own work. You leave with an architecture and a scoped build plan.
- Architect (days). We design the agent loop, the MCP server set, the permission boundaries, and the verification checks: rules-based feedback for the deterministic parts, human approval for the rest.
- Deploy (the 2 to 4 week slice). We build and ship one thin production slice against real data and real users, not a sandbox demo.
- Iterate. We watch it run, tighten the prompts and tools, and move the agent up the ladder or add the next agent once the first one holds.
Where it pays off
- Repetitive internal work that spans several tools, where a human currently copies data between systems.
- Engineering support tasks: triaging issues, drafting pull requests, answering questions grounded in a real codebase.
- Operations workflows in Slack or a ticketing system where an agent can draft, stage, or, with approval, act.
- Any place where retrieval alone falls short and the system has to do something with the answer.
If the honest answer is that you need search and summarization rather than action, we will tell you, and a generative AI development or Claude development engagement is the better fit.
Pricing and engagement
Every engagement starts with a fixed-fee discovery sprint, so the first cost is known before you commit to a build. Build work is then scoped per project against the discovery plan. We do not publish a per-agent rate, because the tool integrations and the verification requirements drive the effort far more than the agent itself does. Discovery exists to make that scope concrete.
Book a discovery call
If you have a workflow that needs software to take action and you want senior engineers who specialize in the Claude Agent SDK and MCP rather than a generalist shop, start with discovery. We will tell you where your agent sits on the action ladder and what a first slice would cost to ship.