Proofpress

Trust infrastructure for RSI.

Proofpress is the Intelligence Ledger for agent-native organizations. It
turns agent-produced learnings into organization-owned intelligence with
evidence, evaluation, scope, human authority, declared use, and outcomes.

Own your intelligence. Verified. Governed. Cumulative.

Website · Quick start ·
Product thesis · Remote MCP

Agent output is growing faster than organizations can trust—or retain

Every run can produce findings, decisions, failures, and learnings that should
change future work. Two failures prevent that intelligence from compounding:

_{Illustrative model, not measured data. Without a trusted learning loop,
the gap keeps widening.}

Today's stack captures pieces—not trusted intelligence

These systems are complementary. They can provide evidence to Proofpress or
consume governed context from it. Proofpress supplies the governed record of
what agents learned, why it is trusted, and where it may be reused.

The Intelligence Ledger

Any agent can propose a learning with evidence through MCP, CLI, Python, or
HTTP. Proofpress records the exact version, evaluates its support and scope,
and routes it through Human Admission. Only admitted, current, in-scope
knowledge becomes governed context for future work.

1. Propose with evidence. Preserve the source, version, and intended scope.
2. Evaluate. Apply deterministic checks and optional model or external
   assessments.
3. Govern. An authenticated human admits, rejects, or requests revision.
4. Reuse deliberately. Record the exact governed context presented and the
   claim versions an agent explicitly relied on.
5. Connect outputs and outcomes. Keep artifact hashes, tests, feedback, and
   later observations attached to the work.
6. Improve through governance. Use new evidence and outcomes to propose the
   next review without silently rewriting organizational truth.

Agents may submit, propose, evaluate, and retrieve. They may never admit their
own claims or administer owner authority.

An open intelligence layer

MCP, CLI, Python, and HTTP call the same versioned lifecycle. Models, agents,
workflows, and harnesses can change while the Intelligence Ledger stays with
the organization.

The ledger records the relationship between a task, the governed context it
received, declared reliance, external outputs, and later observations. This is
the foundation for continuous organizational learning; it does not collapse
evaluation, real-world outcomes, and Human Admission into one score.

The Owner workspace is the human authority layer: review the candidate and its
support, inspect lineage, then admit, reject, or request revision.

Task run tracking documents the append-only Run,
ContextReceipt, Reliance, Output, and Observation contracts.

Quick start

Agent plugin (recommended)

The public proofpress plugin packages the
governed-context workflow, its default repository policy, and the OAuth-protected
Hosted MCP server. It is a distribution layer: the hosted service remains the
authority for workspace access and Human Approval.

Connection prerequisite: installing the plugin does not create a ledger or
a Hosted Proofpress workspace. It connects an agent to an existing Proofpress
workspace. The checked-in default MCP endpoint is the maintainer's private
reference service, not a public multi-tenant cloud; an unprovisioned user must
not use it. Use either a separately provisioned Hosted workspace and its
agent-specific authorization, or replace the MCP URL with a self-hosted
Proofpress /mcp endpoint.

• Codex / ChatGPT: add this repository's .agents/plugins marketplace,
  then install proofpress from the Plugins Directory.
• Claude Code: add this repository as a plugin marketplace, then install
  proofpress@proofpress-plugins.
• Cursor: install the portable Agent Plugin from the Cursor Marketplace
  after its listing is approved, or load plugins/proofpress locally while
  evaluating the package.

The source package is public now; third-party marketplace listings are pending
their independent review. See the plugin release checklist
for the exact publication state and fallback installation paths.

Manual skill and MCP setup

Proofpress requires Python 3.11 or newer. Install both the project-level agent
skill and the local MCP/CLI in the repository where the governed work happens.

1. Install the governance skill. It tells compatible agents when to retrieve,
   propose, and stop for Human Approval.

mkdir -p .agents/skills/proofpress-governed-context
curl -fsSL \
  https://raw.githubusercontent.com/chenmingtang830/proofpress/main/.agents/skills/proofpress-governed-context/SKILL.md \
  -o .agents/skills/proofpress-governed-context/SKILL.md

1. Add a repository policy. Edit and commit it to define what this workflow
   should and should not propose.

mkdir -p .proofpress
curl -fsSL \
  https://raw.githubusercontent.com/chenmingtang830/proofpress/main/.agents/skills/proofpress-governed-context/assets/context-policy.yaml \
  -o .proofpress/context-policy.yaml

1. Install the local MCP and CLI.

uv tool install --with "mcp>=2,<3" "git+https://github.com/chenmingtang830/proofpress.git"

1. Create a governed demo workspace.

proofpress quickstart

• Creates a new ./proofpress-demo Git repository with synthetic evidence.
• Prints a ready-to-copy local proofpress-mcp.json.
• Requires no account, token, hosted service, or model call.
• Add --ui for local review, or --no-browser to keep it terminal-only.
• Configure the optional LM Judge separately with the
  evidence-support criteria.
• Building Proofpress itself? Use the contribution guide.

Use the Python client

Run the same lifecycle in-process or over HTTP:

from proofpress import ProofpressClient, ProofpressError

client = ProofpressClient.in_process(".")
evidence = client.import_evidence("run.otlp.json", idempotency_key="run-001")
candidate = client.propose_claim(
    "The bounded result is ready for review.",
    evidence["evidence"],
    scope="experiment:demo",
    proposer="agent:runner",
    idempotency_key="proposal-001",
)

# A human authorizer reviews through the owner surface. A successor agent reads:
context = client.context(scope="experiment:demo", actor="agent:successor")

Connect an MCP client

• The quickstart prints this local stdio configuration with absolute paths filled in.
• For another workspace, point --workspace at the Git repository Proofpress should govern.

{
  "mcpServers": {
    "proofpress": {
      "command": "/absolute/path/to/proofpress/.venv/bin/proofpress",
      "args": ["mcp", "--transport", "stdio", "--workspace", "/absolute/path/to/workspace"],
      "env": {"PROOFPRESS_MCP_PRINCIPAL": "agent:your-client"}
    }
  }
}

• Hosted: open /connect and use its secret-free remote MCP URL.
• Authentication: OAuth with PKCE binds each client to a separate agent credential.
• Details: Remote MCP.

Choose a deployment

• One local repository: use the in-process client or localhost HTTP for a
  Git-backed ledger, local review, and governed-context reads.
• One owner across devices or agents: use proofpress hosted for durable
  storage, scoped credentials, owner review, and HTTP/MCP access.
• Workflow-specific evidence: use a profile or integration for typed
  validation without changing the authority model.
• Owner UI preview: run npm run preview:local from web/owner; it reuses
  one ignored, mode-0600 local credential and synthetic workspace.
• Hosted boundary: the reference deployment is private, single-owner, and
  single-instance—not a multi-tenant Proofpress cloud. See Self-hosting.

Self-host in three steps

1. Deploy this repository with render.yaml, or use the
   provider-neutral examples in deploy/self-hosted/.

2. In a private server shell, bootstrap one owner workspace:

   proofpress hosted --database /var/data/proofpress.db \
     bootstrap --workspace-id workspace:personal \
     --owner-principal human:owner
   

3. Store the one-time owner credential and recovery secret outside Git, then
   issue a distinct credential for each agent or device. Configure backups
   before relying on the instance.

• The Blueprint contains no Proofpress credentials or customer data.
• A fork uses the operator's own account, storage, domain, and billing.

• Submitting evidence or proposing a claim never admits it.
• Agent credentials identify and constrain callers; they do not carry owner authority.
• Governed-context reads return only admitted, current, in-scope, actor-eligible claims.

Integrations and deployment

• proofpress.profiles.experiment validates bounded metric, table-cell, and derivation evidence.
• proofpress.integrations.repository binds one repository change to Git and check receipts for self-dogfood.
• proofpress.integrations.matter_catalog and proofpress.integrations.document_extraction are optional evidence-entry integrations. Their output remains candidate evidence.
• proofpress hosted runs the single-owner hosted control plane and web review surface. See Self-hosting.

Read this next

• Understand the product: Thesis → claims and governed context → FAQ.
• Connect an agent: trace integration → content-addressed receipt adapter → spreadsheet cell evidence → MCP and WebMCP → repository dogfood.
• Run it privately: self-hosting guide → render.yaml → deployment examples.
• Explore prior experiments: study catalog. Research evidence is separately scoped; it is not a blanket product-efficacy claim.

• Python-first and single-owner today.
• No multi-owner workspaces or customer VPC packaging.
• No Notion or multi-repository knowledge ingestion.
• Not a universal OCR, RAG, memory, or search platform.

Compatibility

Python is the supported SDK and CLI installation path. Older Python imports,
console aliases, and portable top-level commands remain deprecated forwarding
shims; new integrations should use ProofpressClient, proofpress, and
proofpress legacy ... for the portable artifact ledger. Browser tooling is
used internally to build the landing page and Owner workspace; it is not a
customer integration surface.

See the documentation index, study catalog, and GitHub Releases.