MCP engineering.On the real path.
Build, repair and migrate MCP implementations with your coding agent. Follow the active path from the caller to what actually happens.
Get the pluginThe source changed. The running copy didn’t.
src/server.ts
Handler updated to revision B
dist/server.js
Still contains revision A
node dist/server.js
Still returns the old result
The caller never reaches the edited source. Trace its selected entrypoint before changing the handler again.
Use the repair workflowStart with what
you need to ship.
One entrypoint for the work at hand. Choose a task and take a concrete starting prompt into your coding agent.
Build the path the caller will use.
Turn the requested capability into a working MCP implementation, with controls at the layer that owns the effect.
Use $mcp-boundary to build the requested MCP capability. Identify the intended caller, entrypoint, transport and protocol revision; implement it on the active path, place controls at the owning layer, and verify the requested behavior. Keep the scope proportional to the task.
Fix the path that actually runs.
Follow the failing call through the selected entrypoint. Repair the owning layer, then reconcile the built artifact with the running process.
Use $mcp-boundary to repair this MCP integration. Trace the active caller, entrypoint, transport, handler, package and runtime. Implement the fix on that path and run the narrowest check that can reject the original failure. State what remains unverified.
Move the implementation. Close the old path.
A migration also has callers, packages and runtimes to move. Find the still-active dependencies before retiring superseded behavior.
Use $mcp-boundary to migrate this MCP implementation to the selected revision. Identify evidenced callers and active entrypoints, implement the migration, deliberately retire superseded paths, and reconcile source, package and runtime. Distinguish local checks from named-host results.
Know where the behavior is owned.
Inspect the current implementation without editing it. Separate a protocol requirement from transport controls, deployment policy and host behavior.
Use $mcp-boundary to inspect this MCP implementation without editing it. Trace the active caller, entrypoint, transport, protocol/SDK dispatch, capability effect, package and runtime. Locate control ownership, report bounded findings, and identify the smallest useful next checks.
Test the claim where it can be observed.
Use the exact artifact and observer needed for the claim. A local rendering test has value; a different host still needs its own observation.
Use $mcp-boundary to verify this MCP behavior. Define the claim, exact artifact, active runtime and qualifying observer. Run authorized checks at the relevant boundary, distinguishing source, process, artifact and named-host observations. Do not promote an unobserved host result into success or failure.
Small, clear changes stay small. Read the relevant reference, make the change, check it, and stop.
One install.
Depth when you need it.
Use the skill in your coding agent. Read the engineering method behind its decisions. Reproduce specific boundary behavior in the Lab.
Explore the engineering libraryPlugin
The working entrypoint. A focused skill for building, repairing, migrating and checking MCP implementations.
Guide
The reasoning underneath. Revision-aware profiles, control ownership, case studies and evidence discipline.
Lab
The executable counterpart. An MCP App specimen, local host profiles, package/runtime checks and bounded receipts.
Bring it into your
next MCP task.
Install MCP Boundary, restart Codex, then describe your task. Invoke $mcp-boundary directly when you want an explicit entrypoint.
Install from the repository
codex plugin marketplace add IndelibleVivi/mcp-boundary --ref main codex plugin add mcp-boundary@mcp-boundary
These commands follow main, not a pinned directory release. Restart Codex after installation. A current Codex CLI with Agent Plugin support is required.
What gets installed?
One pure skill with its bundled references and assets. It starts no server, adds no app connector or authentication flow, and sends no analytics or telemetry. The Guide and executable Lab remain repository resources.
How much process does this add?
Only the depth the task needs. A small wording change or local helper does not need an elaborate audit. The skill has an explicit stop rule for small, clear MCP tasks.
What does a successful check establish?
The behavior observed at that boundary. Source, local process, artifact, activated runtime and named-host observations remain distinct. The public library links to the method and runnable checks; this website does not execute them.