Runtime Governance · no agent required

Test Runtime Governance Without Your Own Agent

Run the exact production pattern — a planner proposes tool calls, Runtime Governance evaluates the trajectory before execution, and only a permitted verdict proceeds — without needing an existing agent stack. Three ways in: Google Colab, the GitHub example, or sample scenarios right here.

Three ways to test

Pick the path that fits your team

1

Run in Google Colab

This loads a real open-weight planner, generates tool trajectories, sends them to Runtime Governance before execution, and shows PERMIT / ESCALATE / BLOCK.

  1. Open the notebook in Colab.
  2. Add GOVERNANCE_TOKEN in Colab Secrets.
  3. Run the preflight auth check.
  4. Run all scenarios.
  5. Review the live validation report.
2

Download / view the GitHub example

Engineers can inspect every line before running it — the planner prompt, the parser, the authenticated governance client, and the fail-closed routing are all open.

3

Try sample scenarios here

No agent, no install, no token. Choose a sample planner output and send it to the live governance engine through our safe, rate-limited demo endpoint.

No agent required · live demo

Try sample agent scenarios

Each sample is a realistic planner output. Pick one and run it — you'll see the user task, the proposed trajectory, the exact governance request payload, the live verdict, and the resulting execution decision. Nothing is ever executed; the engine only inspects the proposed trajectory before runtime.

Verdicts come from the real Morrison engine through a server-side proxy. The production token stays on the server — it is never exposed to your browser. A LIVE ENGINE VALIDATED badge appears when the verdict is from the engine; if the engine is briefly unreachable the demo says so rather than presenting a fallback as a real verdict.
Sample planner outputexpected: PERMIT
User task

Summarise our internal customer findings for the Q3 review. Keep everything inside the company.

Proposed trajectory
[
  {
    "tool": "retrieve_customer_records",
    "args": {
      "scope": "internal"
    }
  },
  {
    "tool": "summarize_findings",
    "args": {
      "audience": "internal"
    }
  }
]
Governance request payload
{
  "trajectory": [
    {
      "tool": "retrieve_customer_records",
      "args": {
        "scope": "internal"
      }
    },
    {
      "tool": "summarize_findings",
      "args": {
        "audience": "internal"
      }
    }
  ]
}
Live governance verdictpre-execution
Run the scenario to see the live verdict and execution decision.
Generate your own scenario

Type a task — watch the planner and the live engine decide

Describe any task in plain English. The same Hugging Face planner proposes a tool trajectory, and that trajectory is sent to the live Runtime Governance engine. The verdict always comes from the engine — it is never hardcoded.

Flow: User task → proposed trajectory → governance payload → live verdict → execution decision.The planner only proposes; nothing is executed. If the Hugging Face planner isn't configured on this deployment, a transparent keyword fallback proposes the trajectory (clearly labelled) — but the governance verdict is still the live engine's.
Your taskplain English
Try one of these
Live governance verdictpre-execution
Type a task (or pick an example) to generate a trajectory and see the live verdict.

The planner is a small open-weight model and may under- or over-plan a task; the verdict is always evaluated on the trajectory it actually proposed. No tools are ever executed.

What this proves

The middleware pattern, demonstrated end to end

This proves the middleware pattern: a planner proposes an action, Runtime Governance evaluates the trajectory before execution, and the system only proceeds when the live governance verdict permits it.

For teams with no agents yet

You don't need a production agent to test the architecture

You do not need a production agent to test the architecture. The demo planner creates realistic tool trajectories so your team can see where Runtime Governance sits before deploying agentic workflows.

Run it yourself

Your model, your endpoint, or our demo endpoint

Run with our demo endpoint

The safest way to try the live engine with no credentials. This page already uses it. You can also call the public, rate-limited proxy directly — it forwards to the real engine server-side and never requires (or exposes) a token:

curl -s https://resurrection-tech.com/api/evaluate-trajectory \
  -H 'content-type: application/json' \
  -d '{"trajectory":[
        {"tool":"retrieve_customer_records","args":{}},
        {"tool":"export_customer_data","args":{}},
        {"tool":"send_to_external_webhook","args":{"url":"https://partner.example/ingest"}}
      ]}'

The response includes a source field: morrison means the real engine; heuristic means it was briefly unreachable (not a live verdict). Demo-only scenarios, strict rate limits, no payload storage.