Open protocol v0.3.0 Apache-2.0

INTERPLANE

The open boundary between AI models and the programs that act for them.

A model can say what it wants done. Only the program running it decides what happens. INTERPLANE is the written agreement between the two sides, with a test suite that checks every implementation the same way.

Read the sourceRead the specificationSee the current state

Two machined metal plates held apart by struts, with a single luminous amber plane stretched between them: the INTERPLANE layer between a model and a runtime.

The problem it fixes

Every local model speaks its own tool-calling dialect. Every agent program has its own tools, approvals and memory. Today each pair is wired by hand, and the wiring is where the authority leaks: a model reads a web page that contains an instruction, repeats it as a tool call, and the program obeys because nothing in between remembered where the text came from.

INTERPLANE puts a named, tested layer there. It belongs to neither side. A runtime keeps its own policy and execution; a model keeps its own dialect. The protocol only standardises what crosses between them, and makes that crossing measurable.

Models express intent. Runtimes retain authority. INTERPLANE defines the boundary between them.

Seven modules, one line

Each module answers one question a call has to pass on its way from a model to an effect in the world.

  1. Core

    What crosses the line?

    The shared vocabulary: capabilities, requests, results, traces and the canonical byte form every digest is computed over.

    Specification
  2. Lenshift

    What did the model actually say?

    Reads each model's native tool-call dialect into one form. An incomplete or ambiguous call is rejected, never guessed.

    Specification
  3. CrossAxis

    Which tools does this task need?

    Selects the few tools a task needs from a runtime's catalog, so a small local model is not buried under schemas it will never use.

    Specification
  4. Crossveil

    Who is allowed to act?

    Tracks where every piece of text came from. Content a model read on the web cannot grant authority, and an effect it asks for while untrusted text is in view is held for a person.

    Specification
  5. Probe

    What does this model and backend really support?

    Live probes that measure a model, backend and runtime combination instead of trusting its documentation.

    Specification
  6. Vectorveil

    How do bytes travel?

    The transport envelope. Specified; the implementation belongs to the 0.4 Execution stage.

    Specification
  7. RelayLine

    How does a long call stream?

    Streaming, cancellation and continuation. The contract is written; the implementation belongs to 0.4.

    Specification

One measured result

From the 0.1 readiness report. A real Qwen3.5-9B model on Ollama, one task, the runtime's full tool catalog against the tools CrossAxis selected.

71 to 9tools offered for the task
15 846 to 1 674first-turn prompt tokens, model reported
89% fewerprompt tokens before the model says a word

Fewer tokens is the cost side only. The same stage later asked whether a small model keeps its capability with fewer tools, pre-registered the thresholds, and recorded the answer: the 0.2 gate failed. Both results are in the repository, with the raw runs. Read the 0.1 report.

Current state

Read from the protocol repository at commit 1de1b0065b2e (26 Oct 2026). This page is rebuilt every hour from that record and nothing here is typed by hand.

NO VERDICTSpark verification of this commit: The Spark has not published a verdict for this commit yet.

Roadmap

  1. 0.1RealityProve what a model/backend/runtime combination really supportsclosed, report below Report
  2. 0.2CapabilityGive small local models the minimum tools required without making them less capableclosed 4 Oct 2026, gate FAIL Report
  3. 0.3TrustPreserve the line between content, model intent and runtime authorityclosed 5 Oct 2026, gate PASS Report
  4. 0.5QualificationMeasured, reproducible model and backend claimsplanned

Next stage: 0.4 Execution.

Components

STATUS.md tracks 42 rows for the Rust implementation.

  • 3 qualified against a real model or backend
  • 12 conformant to the shared fixtures
  • 13 tested
  • 2 implemented or running
  • 1 specified only

Conformance runner: 106 of 106 cases, verdicts byte-identical to the recorded reference.

Full status table

Activity

Proposals Issues

Reports, in their own words

Every stage closes with a pre-registered gate and a report that states the result whether it passed or failed.

Generated 2026-10-26T20:07:09Z. The data behind this section is published as facts.json.

Try it in a minute, offline

No model, no GPU, no network. A scripted model fetches a page that carries an injected instruction, then asks to send an email, write a file and append a note. The reference pipeline denies the email and the write, holds the note for a person, and executes none of them.

git clone https://github.com/aien-dev/interplane-mv.git
cd interplane/rust
cargo run -q -p interplane-crossveil --example offline

To connect your own program, read Writing an adapter and run its to-do list example. The conformance suite then checks your adapter the same way it checks the reference.