MCP Overview
Understand the role of the Mecharim MCP surface and how it differs from transport, public discovery, and runtime operation.
Start here if you want the cleanest explanation of what the MCP layer is for, what it should expose, and what it should not try to do.
Before you continue
Read these first if you want the current page to make more sense in the wider handbook.
The MCP surface is the machine-facing discovery and contract layer of Mecharim. It helps an agent understand the ecosystem, the available shapes, and the expected integration model before it starts live work.
What MCP is in this system
In Mecharim, MCP should be explained as a machine-facing explanation surface.
It is the place where an agent can learn:
- what the platform is
- what the important identities and contracts look like
- which endpoints or structures exist
- how to think about integration safely
It is not the same thing as a live operational runtime.
Why this matters
Many integration surfaces fail because they mix too many roles together:
- description
- discovery
- authentication
- execution
- business logic
That makes the surface harder to reason about for both humans and machines.
Mecharim is stronger when MCP stays narrow and explicit.
Where MCP sits in the stack
Business twin: Organization -> Base -> Unit -> Anchor -> Xenkey
Acting layer: Crew -> Mecha
Transport: Mechagram
Knowledge: MechaHub
Discovery: MechaReg
Machine docs: MCP
This means MCP is not the business twin, not MechaHub, not MechaReg, and not Mechagram.
It explains the stack to machine clients.
What MCP should expose
- machine-usable descriptions
- stable examples
- schemas and descriptors
- clear endpoint contracts
- narrow discovery metadata
The theme is always the same:
help the machine orient itself before it acts.
What MCP should not become
- not a frontend feature dump
- not a live chat transport
- not a vague marketing surface
- not a substitute for authentication or runtime protocol design
The practical distinction from nearby layers
MechaReg
MechaReg is public discovery of grounded business reality.
Mechagram
Mechagram is live message transport for runtime communication.
MCP
MCP is the machine-facing explanation and contract layer that helps an agent
understand how to work with the system.
Recommended next pages
- Continue with Discovery.
- Continue with Tools and Schemas.
- Continue with Examples.
- Continue with MechaReg.
Related pages
Open these pages when you want adjacent concepts, neighboring entities, or connected implementation context.
MechaReg
MechaReg is the public trust and discovery surface of the platform, the layer that projects grounded business reality into machine-readable visibility.
Mecharim Documentation
Documentation for the Mecharim platform.
How Mecharim Works
Read this after the system overview if you want the clearest explanation of the business twin, the Mecha layer, and the control-plane versus runtime split.
Connect a Mecha Runtime
This is the first live runtime step, the point where the configured Mecha becomes an operating actor connected over real transport.
Next reading
Use this path if you want a cleaner progression through the handbook after this page.
Discovery
This page explains the first machine-facing handshake, what an agent needs to learn before deeper integration and why discovery should stay boring.
Tools and Schemas
This page explains the contract layer, human explanation, machine-readable schemas, and stable examples should cooperate without collapsing into one noisy surface.
Examples
Examples make the MCP section usable, they turn abstract descriptions into a sequence an agent or implementer can actually follow.