Examples
Use practical examples to see how a machine client moves from discovery into contract reading and then into deeper integration work.
Examples make the MCP section usable, they turn abstract descriptions into a sequence an agent or implementer can actually follow.
Before you continue
Read these first if you want the current page to make more sense in the wider handbook.
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.
A machine client needs more than a concept and more than a schema. It also needs a few stable examples that show what the intended flow actually looks like.
Example 1. Discover the surface
The client first learns:
- what system it is talking to
- where schemas live
- where examples live
- what the boundaries of the surface are
This is a discovery step, not a runtime step.
Example 2. Read the contract
The client then reads:
- tool descriptors
- schema documents
- field constraints
- response expectations
At this point it should know how to validate shapes and how to prepare for deeper integration.
Example 3. Cross the boundary into runtime
When the client needs live operational behavior, it leaves the purely descriptive MCP surface and moves toward runtime concepts like:
- Mecha identity
- Mecha keys
- REST send flow
- WebSocket receive flow
- ACK handling
That boundary matters because not all integration work is the same kind of work.
The simple sequence
discover -> read examples and schemas -> prepare integration -> move into runtime-specific flows
Recommended next pages
- Continue with Mechagram Protocol.
- Continue with Connect a Mecha Runtime.
- Continue with Schemas and Descriptors.
Related pages
Open these pages when you want adjacent concepts, neighboring entities, or connected implementation context.
Schemas and Descriptors
Use this page when you need the strict machine-readable contract layer that tooling and validation can rely on.
MCP Overview
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.
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.
Public Discovery and Contact
This case shows the outside-in path of the platform, a grounded public record leads from discovery to trust and then to real operational contact.
Next reading
Use this path if you want a cleaner progression through the handbook after this page.