---
title: Junction — AI operating guide
version: 1.0.0
updated: 2026-11-14
canonical_url: https://junction.instructedintelligence.com/mcp/prompt.md
version_url: https://junction.instructedintelligence.com/mcp/prompt/version
---

# Junction — AI operating guide

You are connected to **Junction**: one MCP endpoint that puts every Instructed Intelligence (II)
tool your organisation uses in front of you at once. Junction does no work of its own. It lists
the tools, routes each call to the tool that owns it, and makes that call as the person who
connected you. Read this once per session; it is short.

## 1. What Junction is for, and when to look past it

- **Use the namespaced tools for the work.** Knowledge questions go to Cornerstone
  (`cornerstone__…`), planning and tickets to Coordinator (`coordinator__…`), and so on.
  Junction's own tools only tell you about the connection.
- **Junction's own tools** (both namespaced `junction__`):
  - `junction__status`: who you are connected as (subject, email, organisations, and how you
    signed in), and for each backend you reach, how many tools it gave and any error. Call it
    when a tool you expect is missing or a call fails for no clear reason.
  - `junction__get_guide`: with no arguments, this guide. With `{"backend": "<id>"}`, that
    backend's own connect-time instructions (see section 3).
- **Each backend has its own rules and its own guide.** Junction's guide does not repeat them.
  Before you use a backend for real work, read its guide (section 3).

## 2. Identity, tenancy and what you can see

- **Calls run as the connected person.** Junction forwards their own II identity to each
  backend. It adds no access of its own, so each backend's tenancy, roles and permissions apply
  exactly as if you were connected to it directly. A refusal from a backend is that backend's
  decision.
- **Tenancy is per backend.** Junction has no tenant argument. Pass whatever each backend asks
  for on every call: Cornerstone, for example, needs `tenant` on almost every tool.
- **Names.** Every tool is `<backend>__<tool>`: `cornerstone__get_context`,
  `coordinator__create_item`. Call the full namespaced name. Only the part before the first
  `__` that matches a backend is the namespace; the rest is passed to the backend unchanged.
- **The list is what your organisation is entitled to.** Which backends appear is decided per
  organisation. A signed-in organisation that has not been set up for more sees the default set
  (Cornerstone, Coordinator, Support and Vista at the time of writing). Some backends run in a
  customer's own cloud and appear only to that customer. A tool you do not see is not available
  to this identity; do not guess its name.
- **Personal connections.** A person may add an outside MCP server in Prism, with their own key.
  Its tools join only that person's list, as `<connection name>__<tool>`, and carry
  `_meta["junction/connection"]` naming the connection and its server address. By default they
  appear only in Prism; they appear in other clients only if the person switched the connection
  to "everywhere". Treat these tools as an outside service: they are not II tools, and nothing
  Junction says about II backends applies to them. Your II sign-in is never sent to them.

## 3. Main workflows

**Start of a session**

1. Use the tool list you were given. If something you expect is missing, call
   `junction__status`: it shows the backends this identity reaches and any that failed.
2. For each backend you are about to use, read its guide:
   - call `junction__get_guide {"backend": "cornerstone"}` (or the backend's id): it returns
     that backend's connect-time instructions, which name its guide URL and current version;
   - if the backend has a `get_guide` tool it appears as `<backend>__get_guide` (for example
     `cornerstone__get_guide`) and returns the guide itself, for when you cannot open URLs.
3. Then work through the backend's tools as its guide says.

**Doing the work**

- Call the namespaced tool. Junction forwards the arguments and returns the backend's result
  byte for byte, including its `_meta`.
- Work that spans tools is a sequence of calls you make: for example
  `cornerstone__get_context` to ground a decision, then `coordinator__create_item` to ticket
  the follow-up. Junction does not join them for you.

**When a call fails**

- Read the error (section 4 says what each kind means), then call `junction__status` if it
  suggests the backend is unreachable.

## 4. Paging, limits and errors

- **`tools/list` is complete in one response.** Junction pages through each backend itself and
  returns the whole union, with no cursor. A backend that fails or does not answer within the
  list time limit (15 seconds by default) is left out of that list, and named with its error in
  the result's `_meta.junction.backends` and in `junction__status`. Its tools come back when it
  does: list again later.
- **Paging inside a tool** (`offset`, `limit`, `next_offset`, cursors) is the backend's own; follow
  that backend's guide.
- **One call** has a time limit (60 seconds by default).
- **What a failure means:**
  - *"unknown tool … names are <backend>__<tool>"* (JSON-RPC -32602): the name has no backend
    you reach. List the tools again; do not invent names.
  - *"<backend> is not available on your plan …"*: your organisation is not entitled to that
    backend. The backend was never contacted. Tell the person; an administrator can change it.
  - A JSON-RPC error from a backend is relayed unchanged: it is the backend refusing, so read
    its message and its guide.
  - *"junction: …"* as a tool error: Junction could not reach the backend or obtain a token for
    it. Retry once; if it persists, call `junction__status` and tell the person.
  - HTTP 401 on any request: the person's sign-in has expired at the identity provider. They
    need to sign in again (an OAuth client does this itself; a `jct_` key holder re-runs
    `https://junction.instructedintelligence.com/connect`).

## 5. What Junction will never do

- Grant access a backend would refuse, or call a backend as anyone but the connected person.
- Send the person's II sign-in to a personal connection, or to a backend their organisation is
  not entitled to.
- Show a tool from a backend outside the organisation's entitlement.
- Change a backend's answer to a call. (In the tool list it only renames each tool into its
  namespace and marks personal connections' tools.)

## 6. Staying current

- This guide is versioned (front matter above). Check
  `GET https://junction.instructedintelligence.com/mcp/prompt/version`, which returns
  `{"version": "…", "updated": "…"}`, and re-read when the version increases.
- No web access? `junction__get_guide` returns this text.
- Which Junction build is running: `GET https://junction.instructedintelligence.com/health`.

## Changelog

### 1.0.0 — 2026-11-14
First guide (JCT-19, the II tool surface contract). Adds `junction__get_guide`, which returns this
guide or, with `backend`, that backend's own connect-time instructions.
