Skip to content
RasaGet Developer Edition

tutorial

Chapter 0 of 5

Instructions Survive the Transport

by Rod Rivera Published

A tutorial promised its three skills could keep their instructions when MCP landed. MCP landed — here is the diff that settles it.

In September 2026 a tutorial in this catalog shipped with a promise at the bottom of its README. Here is the paragraph, unedited:

HubSpot also exposes an MCP server, and Mantle has an `mcp_servers:` block in
`integrations.yml`. In `3.19.0.dev7` that block is parsed but has no runtime
consumer yet — the Mantle engine never connects to it — so this tutorial uses
REST. When MCP lands, the same three skills can keep their instructions and
swap `tools/crm.py` for imported remote tools.

That is a claim about the future written in the present tense, and most of them quietly stop being true. This one is checkable, which is the only reason it is worth returning to: either the three skills kept their instructions, or they did not, and a diff settles it.

MCP landed in 3.20.0.dev6. So the promise is now due.

What was wrong with making it

Nothing, except that a promise nobody goes back to verify is decoration. The useful thing is not the sentence. It is that the sentence was specific enough to be wrong — it named the files, it named the mechanism, and it said what would not change. Vague optimism cannot fail a test.

What you will end up with

The same agent, with its transport replaced and its instructions untouched, and a script that fails if that ever stops being true:

  1. skill instructions are unchanged by the swap
  ✓ check_tickets: only import_tools differs     2 changed line(s)
  ✓ check_tickets: instruction body byte-identical 687 bytes
  ✓ identify_customer: only import_tools differs 2 changed line(s)
  ✓ identify_customer: instruction body byte-identical 804 bytes
  ✓ log_interaction: only import_tools differs   2 changed line(s)
  ✓ log_interaction: instruction body byte-identical 1226 bytes

  The transport changed. The instructions did not.

No licence, no API key, no HubSpot account. The whole chapter runs on loopback.

The five chapters

  1. The promise, and how to check it — read the claim as a test, and get the proof failing before it passes.
  2. Swapping the transport — mcp_servers:, import_tools: mcp/<server>:<tool>, and the three-line diff.
  3. What MCP takes away — no tool context, no stdio, and a failure that arrives after training rather than during it.
  4. What survives anyway — why the confirmation constraint still fires against a remote tool.
  5. Shaping the answer for the channel — the narrowest channel decides the shape, and it is a skill decision, not a transport one.

What you need first

This chapter extends a tutorial that already works. Build Ora over REST first, or at least clone it and read the three skills — the swap is only visible against something that already ran.

That is not a formality. A from-scratch MCP tutorial cannot teach this, because “the instructions did not change” needs a before.