TL;DR
MCP (Model Context Protocol) is a protocol between a chat application and external tools / data sources. It helps a model that already works out how to call a filesystem, a database, a Jira, or your calendar.
ModelRein (formerly LMCP) is a protocol between an agent and the model's internals. It helps you reach inside a Hugging Face model — residual stream, attention heads, individual layers, final logits — regardless of which open-weight model it is.
They sit on opposite sides of the inference boundary. You can and should use both.
Where each one lives
| MCP | ModelRein | |
|---|---|---|
| Who speaks it | Chat app ↔ tool server | Agent ↔ model server |
| What's on the wire | Tool definitions, context docs, resource URIs | Prompts, interventions, model-internal control (steer, head_mask, layer_route) |
| Model sees it? | Yes — tools become part of the context the model reasons over | No — the agent uses it to steer the model's generation |
| Scope | External world: files, DBs, APIs, services | Internal world: activations, heads, layers, logits |
| Works with | Any model that supports tool calling, hosted or open-source | Any model with loadable Hugging Face weights |
| Closed APIs | Fine — MCP sits above the model | Impossible — closed APIs don't expose activations |
Why that matters
MCP assumes you already have a working model, you just need it to see more of the outside world. ModelRein assumes you want more control over the model itself — making it respond in a specific language without changing the prompt, pruning away an attention head that's causing a known failure mode, running two models in a pipeline where the output tensor of one becomes the input tensor of the next.
MCP works great with closed APIs. ModelRein cannot — there is no POST /v1/chat/completions?skip_layers=[12,20] endpoint on any commercial inference service, and there never will be. That's why ModelRein exists for the open-weight world specifically.
A worked example: both, together
Say you're building an agent that answers accounting questions. It needs:
- Access to the user's QuickBooks data → that's an MCP server exposing
get_invoices(),get_balance(), etc. - A model that refuses to speculate about numbers it can't see → that's an ModelRein intervention: compute a steering vector for "only answer with cited numbers" and inject it at the critical layer every turn.
One session, two protocols, both doing what they're best at. MCP has no notion of what "critical layer" means. ModelRein has no notion of what "list my invoices" means. Neither is a replacement for the other.
What ModelRein has that MCP doesn't
POST /lmcp/compute_vector_auto— contrastive steering vector extraction from pos/neg exemplars.POST /lmcp/head_mask— mute, scale, or redirect specific (layer, head) pairs. The ITI paper in one HTTP call.POST /lmcp/layer_route— skip layers at inference time (Mixture-of-Depths without retraining).POST /lmcp/logit_bias— EOS bias ramps, token-level control, length constraints.POST /lmcp/pipeline— chain N heterogeneous models with field-level binding. Our front page runs 8 models through this in one call.
What MCP has that ModelRein doesn't
- Resource URIs and content streams for file-like data.
- A notification protocol for tool state changes.
- A client ecosystem built around desktop chat apps.
- Vendor-neutral tool definitions that work against closed APIs.
The naming overlap
If you squint, both are "protocols that let something talk to a model." That's true, but the something and the side of the model are different. MCP = outside, context goes in. ModelRein = inside, control goes in.
Related: Why model-agnostic agents need a control protocol · Controlling Qwen, Llama, and DeepSeek with one agent · What is ModelRein?
