Explicit authority
Retain actors, authority, pathway state, and authorized transitions instead of reducing governance to a boolean check.
MIT-licensed Public Alpha · 0.1.0a2
Keep the responsibility path intact when software acts.
RPR is a Python runtime for applications that need explicit authority, attempt continuity, independent readback, fail-closed ambiguity handling, repair routes, and a human return point around consequential external actions.
- Version
- 0.1.0a2
- Tag
- v0.1.0a2
- Final rehearsal
- Linux · Python 3.11
Request
↓Actor + Authority
↓RPR Pathway
↓Executor + Readback
↓Evidence · Repair · Human Gate
Verified locally executable scope
A runtime boundary built for uncertainty, not optimistic completion.
Attempt continuity
Bind operations, attempts, and idempotency identity across retry, restart, repair, and reconciliation.
Independent readback
Completion requires evidence from the affected domain rather than trusting a dispatch response alone.
Fail-closed ambiguity
Post-dispatch uncertainty remains write_status_unknown; RPR does not silently replay an unresolved effect.
Human return point
Hold, repair, resume, and Human Gate ownership remain explicit and cannot be cleared by an unsupported shortcut.
Operational evidence
Verified paths include HTTP, MCP subprocess, restart, backup/restore, diagnostics, removal, and retained customer data.
Integration model
RPR governs the pathway. Your host governs the deployment.
The host application remains responsible for authentication, credentials, network and storage controls, bypass prevention, domain-specific authorization, and the independent readback source.
RPR owns pathway lifecycle, execution-attempt continuity, evidence retention, fail-closed ambiguity, and explicit return to an authorized human or repair route.
Current MCP support
Govern outbound MCP tool calls without pretending the response proves the effect.
RPR can sit between a host application and a local MCP server. The current Public Alpha includes subprocess launch, stdio transport, JSON-RPC framing, server and tool admission binding, execution-attempt continuity, and fail-closed handling when a call may have been sent but no reliable result exists.
For consequential tools, a successful MCP response is not enough by itself. RPR can require independent readback and retain write_status_unknown when the effect cannot be verified.
Operational demonstration
A real failure-and-recovery path, not a mocked success screen.
The browser demo loads the CI-built RPR wheel into Pyodide and runs the actual runtime, SQLite persistence, attempt history, unknown-write handling, restart recovery, and reconciliation logic. Only the external provider is simulated.
Help expand real-world evidence
Use it in your environment. Report what actually happens.
We are looking for reproducible Issues from Windows, macOS, additional Linux distributions, containers, proxy/TLS routes, enterprise identity, remote MCP, service integrations, frameworks, and operational workflows.
Quick Start
Install the pinned Public Alpha from PyPI.
The source repository, GitHub Prerelease, PyPI package, product site, and live browser demo are public. Start in an isolated, disposable environment.
python3.11 -m venv .venv
. .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install responsibility-pathway-runtime==0.1.0a2
rpr --help