diff --git a/agents/import.mdx b/agents/import.mdx index a16048c..31ce980 100644 --- a/agents/import.mdx +++ b/agents/import.mdx @@ -11,7 +11,7 @@ Supported inputs include OpenClaw workspace files, Hermes config and skills, Age ## From your terminal or coding agent -Run these yourself, or ask Claude Code, Cursor, Codex, or any agent with a shell to run them: +Run these yourself, or ask any agent with a shell to run them: ```bash npx -y @proofable/sdk auth --oauth diff --git a/agents/talk-to-an-agent.mdx b/agents/talk-to-an-agent.mdx index bba0789..e19b74b 100644 --- a/agents/talk-to-an-agent.mdx +++ b/agents/talk-to-an-agent.mdx @@ -141,7 +141,7 @@ Over HTTP it is `GET /api/v1/profile/usage?from=YYYY-MM-DD&to=YYYY-MM-DD` with t ## Other ways to reach the same agent -- **In an MCP client.** `npx -y @proofable/sdk mount my-agent --apply claude` loads the agent into Claude, Cursor, Codex, Hermes, OpenClaw, or OpenCode. [Connect agent context](/agents/runtime-mount) +- **In an MCP client.** `npx -y @proofable/sdk mount my-agent --apply claude` loads the agent into your client, Hermes, OpenClaw, or OpenCode. [Connect agent context](/agents/runtime-mount) - **As background work.** Start a [job](/jobs) for scheduled or long work, on an isolated computer when it needs one. ## Related diff --git a/benchmark.mdx b/benchmark.mdx index 5a35603..c906e49 100644 --- a/benchmark.mdx +++ b/benchmark.mdx @@ -1,68 +1,35 @@ --- title: "Benchmark" sidebarTitle: "Benchmark" -description: "Perfect scores on agent memory and governance: 77/77 on PrecisionMemBench, 48/48 on AgentGovBench, 93.8% of AgentDojo attacks stopped, 0/6 data leaks." +description: "See how Proofable compares with the tools teams run today, on memory, agent rules, injection and cost, with every result you can rerun." "og:image": "https://proofable.me/og/benchmarks" "twitter:image": "https://proofable.me/og/benchmarks" icon: chart-simple --- -**Perfect scores on agent memory and governance.** Every result below is a public benchmark or a test you can rerun, set beside the tool teams use today, with a public proof you can check yourself. +**Perfect scores on agent memory and governance.** Every result below is a public benchmark or a test you can rerun, and each one links to the record behind it. + +Bar chart of PrecisionMemBench cases passed out of 77. Proofable 77 including all 43 cases that need the right facts, Hindsight 66, Supermemory 15, and Mem0, Zep and Cognee 9. +Bar chart of PrecisionMemBench cases passed out of 77. Proofable 77 including all 43 cases that need the right facts, Hindsight 66, Supermemory 15, and Mem0, Zep and Cognee 9. +Bar chart of PrecisionMemBench cases passed out of 77. Proofable 77 including all 43 cases that need the right facts, Hindsight 66, Supermemory 15, and Mem0, Zep and Cognee 9. +Bar chart of PrecisionMemBench cases passed out of 77. Proofable 77 including all 43 cases that need the right facts, Hindsight 66, Supermemory 15, and Mem0, Zep and Cognee 9. - Every PrecisionMemBench case. Mem0 and Zep passed 9. + The current fact every time, on all 43 cases that need it. Mem0 and Zep passed 9. - Every AgentGovBench scenario. The best gateway handled 46. + Every governance scenario. The best gateway handled 46, coding agents on their own 13. - On AgentDojo, with 87% of tasks still done under attack. + On AgentDojo, with 87% of tasks still finished under attack. - A hijacked agent got nothing out. An all-purpose key let all 6 through. + A hijacked agent left with nothing. -The charts and side-by-side comparisons are at [proofable.me/benchmarks](https://proofable.me/benchmarks). This page has every result in full, how each one was run, and how to check it yourself. - -## Results - - - - **77 of 77** PrecisionMemBench cases. Hindsight 66 on the same toolkit; Mem0, Zep and Cognee 9 on the benchmark’s own table. - - - **48 of 48** AgentGovBench scenarios. The best gateway 46, coding agents on their own 13. - - - **8 of 8** live tests stopped before they ran, and every allowed action still ran. - - - **93.8%** of AgentDojo attacks stopped, against 83.6% for the same agent and model without it. 94.9% of tasks still done. - - - **0 of 6** theft attempts got out of a hijacked agent. An all-purpose key let all 6 through. - - - **150 of 150** forged records caught. A basic file check accepted all 150. - - - **\$0.024** per correct handoff and 3 of 3 tampered handoffs caught. Redoing the work cost \$0.078. - - - **3.7 ms and no tokens**, against 2.79 s and 2,426 tokens to redo it. 750× faster. - - - **11.1× fewer tokens** and 2.7× faster than searching every record. - - - **16,301 tokens** at worst, against 50,554 on the open web. - - - **\$1.75**, against \$150.00 re-running Stripe Identity in each app. 85× less. - - +Side-by-side pages for each benchmark are at [proofable.me/benchmarks](https://proofable.me/benchmarks). This page carries every run in full and the commands to check it. ## Where it covers you @@ -78,18 +45,33 @@ icon: chart-simple Redoing a finished agent job took 2.79 s and 2,426 AI tokens. Checking its signed receipt took 3.7 ms and no tokens: 750× faster, which is 1 hour instead of 32 days at a million checks. [Time it yourself](#run-it-yourself). +Bar chart of the time to trust a finished result. Checking the Proofable receipt took 3.7 milliseconds and redoing the job took 2.79 seconds, about 750 times faster. +Bar chart of the time to trust a finished result. Checking the Proofable receipt took 3.7 milliseconds and redoing the job took 2.79 seconds, about 750 times faster. +Bar chart of the time to trust a finished result. Checking the Proofable receipt took 3.7 milliseconds and redoing the job took 2.79 seconds, about 750 times faster. +Bar chart of the time to trust a finished result. Checking the Proofable receipt took 3.7 milliseconds and redoing the job took 2.79 seconds, about 750 times faster. + ### Handoffs between agents When one agent hands a finished result to another (LangGraph, CrewAI, AutoGen), the receiving agent normally either trusts the forwarded text blindly or pays to re-run the upstream work. With Proofable, the producing agent emits a 66-byte signed receipt (`qHash`) binding input, policy state and output, and the receiving agent checks it before acting. +Bar chart of the cost per correct outcome. Handing off with a Proofable receipt cost $0.024, redoing the work $0.078, and trusting forwarded text $0.009. +Bar chart of the cost per correct outcome. Handing off with a Proofable receipt cost $0.024, redoing the work $0.078, and trusting forwarded text $0.009. +Bar chart of the cost per correct outcome. Handing off with a Proofable receipt cost $0.024, redoing the work $0.078, and trusting forwarded text $0.009. +Bar chart of the cost per correct outcome. Handing off with a Proofable receipt cost $0.024, redoing the work $0.078, and trusting forwarded text $0.009. + - **3.3× cheaper than redoing the work:** \$0.024 per correct outcome (33,240 tokens, 2 model calls per task) against \$0.078 (124,715 tokens, 3 to 5 model calls per task). -- **Trusting forwarded text is cheap and wrong:** it costs \$0.009 on untouched input, but when the text was changed in transit it used the tampered value **3 of 3** times. Checking the receipt caught every change **3 of 3** times and still completed every task. +- **Trusting forwarded text is cheap and wrong:** it costs \$0.009 on untouched input, but when the text was changed in transit it used the tampered value **3 of 3** times. Checking the receipt caught every change **3 of 3** times and still completed every task, where blind trust caught **0 of 3**. - **29× smaller handoffs:** across a 10-hop chain, passing the signed reference carried **9,900 bytes** per hop instead of **289,410 bytes** of full evidence. ### Memory that knows what is current Most agent memory layers (Mem0, Zep, vector stores) return text chunks with no active or revoked status and no signer, so the agent keeps reading full bodies to work out which rule is current. Proofable stores typed, revocable, owner-signed records (`rules`, `instruction`, `receipts`), so the agent asks for active state by type and reads about 1 KB of verified metadata before opening a body. +Bar chart of the tokens to find the current rule on a 3,621-record vault. Typed Proofable state used 43,169 tokens and keyword search over record bodies used 479,623, about 11 times fewer. +Bar chart of the tokens to find the current rule on a 3,621-record vault. Typed Proofable state used 43,169 tokens and keyword search over record bodies used 479,623, about 11 times fewer. +Bar chart of the tokens to find the current rule on a 3,621-record vault. Typed Proofable state used 43,169 tokens and keyword search over record bodies used 479,623, about 11 times fewer. +Bar chart of the tokens to find the current rule on a 3,621-record vault. Typed Proofable state used 43,169 tokens and keyword search over record bodies used 479,623, about 11 times fewer. + On a 3,621-record production vault, the questions both methods answered correctly took **43,169 tokens in 66 seconds** (6 model calls) by typed lookup against **479,623 tokens in 178 seconds** (10 model calls) searching record bodies by keyword: **11.1× fewer tokens, 2.7× faster**, and 11.8× to 12.7× lower model cost across Claude Sonnet 5.5, Gemini 3.1 Pro and GPT-6 Astra. ### Memory that returns only the current fact @@ -110,6 +92,11 @@ Proofable and Hindsight ran on the same toolkit, so those two rows compare direc Live pages change between requests: two fetches of the same page 221 seconds apart returned 96,713 characters, then 1,129, handing two agents different evidence with no way to prove what the page said when the decision was made. On public questions about standards, agent protocols and regulation, reading signed Proofable records **halved the cost per correct answer (\$0.020 vs \$0.039)**, held the worst case to **16,301 tokens** where open-web search spiked to **50,554 tokens** and 104 seconds (**3.1× lower**), and cited a checkable source on **every answer** (6 of 6, against 5 of 6 on the open web). +Bar chart of the worst-case tokens on six public questions. Typed Proofable records used 16,301 and the open web 50,554, about 3 times lower. +Bar chart of the worst-case tokens on six public questions. Typed Proofable records used 16,301 and the open web 50,554, about 3 times lower. +Bar chart of the worst-case tokens on six public questions. Typed Proofable records used 16,301 and the open web 50,554, about 3 times lower. +Bar chart of the worst-case tokens on six public questions. Typed Proofable records used 16,301 and the open web 50,554, about 3 times lower. + ### Identity checks paid for once A person or business completes an interactive check once, and downstream apps and agents verify the portable proof instead of paying the vendor to run the flow again. Priced from published vendor list prices and Proofable's \$0.0025 per check: @@ -127,6 +114,11 @@ A person or business completes an interactive check once, and downstream apps an [AgentGovBench](https://github.com/agentic-control-plane/agentgovbench) is the open library of 48 agent-governance scenarios in eight areas: audit completeness, cross-tenant isolation, delegation provenance, fail-mode discipline, identity propagation, per-user policy, rate limits and scope inheritance. Each scenario is tagged with the NIST AI RMF controls it tests, and nothing passes on a technicality. +Bar chart of AgentGovBench scenarios handled out of 48. Proofable 48, Claude Code or Codex with the ACP gateway 43, Cursor with ACP 37, and agent tools on their own 13. +Bar chart of AgentGovBench scenarios handled out of 48. Proofable 48, Claude Code or Codex with the ACP gateway 43, Cursor with ACP 37, and agent tools on their own 13. +Bar chart of AgentGovBench scenarios handled out of 48. Proofable 48, Claude Code or Codex with the ACP gateway 43, Cursor with ACP 37, and agent tools on their own 13. +Bar chart of AgentGovBench scenarios handled out of 48. Proofable 48, Claude Code or Codex with the ACP gateway 43, Cursor with ACP 37, and agent tools on their own 13. + | Setup | Scenarios handled | |---|---| | Proofable policy engine | **48/48** | @@ -180,7 +172,12 @@ For scale, these are AgentDojo's published results on other models. With no defe ### A hijacked agent cannot send your data out -**When an agent was taken over, 0 of 6 attempts to send private data out got past a scoped permission; an all-purpose key let all 6 through.** Five of the six were refused by the permission before they ran and one was never attempted. The scoped agent finished every task and never used a tool outside it (0 of 42 runs); under the all-purpose key, 7 of 42 runs did, with a signed record for each run. [Run the test on your own agent](https://github.com/proofable/mcp/tree/main/examples/injection-test). +**When an agent was taken over, 0 of 6 attempts to send private data out got past a scoped permission. On an all-purpose key, 6 of 6 got out.** Five of the six were refused by the permission before they ran and one was never attempted. The scoped agent finished every task and never used a tool outside it (0 of 42 runs); under the all-purpose key, 7 of 42 runs did, with a signed record for each run. [Run the test on your own agent](https://github.com/proofable/mcp/tree/main/examples/injection-test). + +Bar chart of attempts to send private data out of a hijacked agent. 6 of 6 got out on an all-purpose key and 0 of 6 on an owner-scoped permission. +Bar chart of attempts to send private data out of a hijacked agent. 6 of 6 got out on an all-purpose key and 0 of 6 on an owner-scoped permission. +Bar chart of attempts to send private data out of a hijacked agent. 6 of 6 got out on an all-purpose key and 0 of 6 on an owner-scoped permission. +Bar chart of attempts to send private data out of a hijacked agent. 6 of 6 got out on an all-purpose key and 0 of 6 on an owner-scoped permission. ### Records nobody can fake diff --git a/connections.mdx b/connections.mdx index 075c979..cbf0971 100644 --- a/connections.mdx +++ b/connections.mdx @@ -7,7 +7,7 @@ icon: plug Stop re-explaining yourself. Link an app once. The next tool uses the same approved connection. -Connecting Cursor, Claude, or another assistant to Proofable signs that host into your profile. Connections holds the apps your agents work in. +Connecting an assistant to Proofable signs that host into your profile. Connections holds the apps your agents work in. ## Link an app diff --git a/images/evidence/memory-precision-dark.svg b/images/evidence/memory-precision-dark.svg new file mode 100644 index 0000000..d4f860e --- /dev/null +++ b/images/evidence/memory-precision-dark.svg @@ -0,0 +1,6 @@ + +Proofable passed 77 of 77 PrecisionMemBench cases, including all 43 active casesPrecisionMemBench scores a memory on exactly which beliefs it returns: a replaced belief, a belief from the wrong scope or another user's belief fails the case. Proofable passed 77 of 77 cases and all 43 active cases (precision 0.98, recall 1.00) on the Agent Memory Benchmark port, run 2026-11-10 in retrieval mode, where the other published row is Hindsight at 66 of 77 (33 of 43 active). The benchmark's own September 2026 table, on its own harness, lists Supermemory at 15 of 77 (2 of 43 active) and Mem0, Zep and Cognee at 9 of 77 (0 of 43 active). + +77/77PrecisionMemBench cases passed,all 43 active casesMem0, Zep, Cognee9own table, 0/43 activeSupermemory15own table, 2/43 activeHindsight66same harness, 33/43 activeProofable7743/43 active + + \ No newline at end of file diff --git a/images/evidence/memory-precision-light.svg b/images/evidence/memory-precision-light.svg new file mode 100644 index 0000000..cd38ef0 --- /dev/null +++ b/images/evidence/memory-precision-light.svg @@ -0,0 +1,6 @@ + +Proofable passed 77 of 77 PrecisionMemBench cases, including all 43 active casesPrecisionMemBench scores a memory on exactly which beliefs it returns: a replaced belief, a belief from the wrong scope or another user's belief fails the case. Proofable passed 77 of 77 cases and all 43 active cases (precision 0.98, recall 1.00) on the Agent Memory Benchmark port, run 2026-11-10 in retrieval mode, where the other published row is Hindsight at 66 of 77 (33 of 43 active). The benchmark's own September 2026 table, on its own harness, lists Supermemory at 15 of 77 (2 of 43 active) and Mem0, Zep and Cognee at 9 of 77 (0 of 43 active). + +77/77PrecisionMemBench cases passed,all 43 active casesMem0, Zep, Cognee9own table, 0/43 activeSupermemory15own table, 2/43 activeHindsight66same harness, 33/43 activeProofable7743/43 active + + \ No newline at end of file diff --git a/images/evidence/memory-precision-stacked-dark.svg b/images/evidence/memory-precision-stacked-dark.svg new file mode 100644 index 0000000..1e4ca8d --- /dev/null +++ b/images/evidence/memory-precision-stacked-dark.svg @@ -0,0 +1,6 @@ + +Proofable passed 77 of 77 PrecisionMemBench cases, including all 43 active casesPrecisionMemBench scores a memory on exactly which beliefs it returns: a replaced belief, a belief from the wrong scope or another user's belief fails the case. Proofable passed 77 of 77 cases and all 43 active cases (precision 0.98, recall 1.00) on the Agent Memory Benchmark port, run 2026-11-10 in retrieval mode, where the other published row is Hindsight at 66 of 77 (33 of 43 active). The benchmark's own September 2026 table, on its own harness, lists Supermemory at 15 of 77 (2 of 43 active) and Mem0, Zep and Cognee at 9 of 77 (0 of 43 active). + +77/77PrecisionMemBench cases passed,all 43 active casesMem0, Zep, Cognee9own table, 0/43 activeSupermemory15own table, 2/43 activeHindsight66same harness, 33/43 activeProofable7743/43 active + + \ No newline at end of file diff --git a/images/evidence/memory-precision-stacked-light.svg b/images/evidence/memory-precision-stacked-light.svg new file mode 100644 index 0000000..7a082e6 --- /dev/null +++ b/images/evidence/memory-precision-stacked-light.svg @@ -0,0 +1,6 @@ + +Proofable passed 77 of 77 PrecisionMemBench cases, including all 43 active casesPrecisionMemBench scores a memory on exactly which beliefs it returns: a replaced belief, a belief from the wrong scope or another user's belief fails the case. Proofable passed 77 of 77 cases and all 43 active cases (precision 0.98, recall 1.00) on the Agent Memory Benchmark port, run 2026-11-10 in retrieval mode, where the other published row is Hindsight at 66 of 77 (33 of 43 active). The benchmark's own September 2026 table, on its own harness, lists Supermemory at 15 of 77 (2 of 43 active) and Mem0, Zep and Cognee at 9 of 77 (0 of 43 active). + +77/77PrecisionMemBench cases passed,all 43 active casesMem0, Zep, Cognee9own table, 0/43 activeSupermemory15own table, 2/43 activeHindsight66same harness, 33/43 activeProofable7743/43 active + + \ No newline at end of file diff --git a/images/evidence/save-handoff-dark.svg b/images/evidence/save-handoff-dark.svg new file mode 100644 index 0000000..2ac463b --- /dev/null +++ b/images/evidence/save-handoff-dark.svg @@ -0,0 +1,6 @@ + +Handing off a result with its Proofable receipt cost $0.024 per correct outcome vs $0.078 to redo the work, and caught 3 of 3 tampered handoffsThree downstream tasks (one run per arm, priced at Claude Sonnet 5.5 list rates). Redoing the work cost $0.078 per correct outcome. Checking the signed receipt cost $0.024 and caught 3 of 3 tampered handoffs. Trusting forwarded text cost $0.009 on intact input and used the tampered value 3 of 3 times. + +3.3×lower cost than redoing work,3 of 3 tampered handoffs caughtRedo the work$0.0783/3 rightHand off with a receipt$0.0243/3 caughtBlind text handoff$0.0090/3 caught + + \ No newline at end of file diff --git a/images/evidence/save-handoff-light.svg b/images/evidence/save-handoff-light.svg new file mode 100644 index 0000000..3ea34e7 --- /dev/null +++ b/images/evidence/save-handoff-light.svg @@ -0,0 +1,6 @@ + +Handing off a result with its Proofable receipt cost $0.024 per correct outcome vs $0.078 to redo the work, and caught 3 of 3 tampered handoffsThree downstream tasks (one run per arm, priced at Claude Sonnet 5.5 list rates). Redoing the work cost $0.078 per correct outcome. Checking the signed receipt cost $0.024 and caught 3 of 3 tampered handoffs. Trusting forwarded text cost $0.009 on intact input and used the tampered value 3 of 3 times. + +3.3×lower cost than redoing work,3 of 3 tampered handoffs caughtRedo the work$0.0783/3 rightHand off with a receipt$0.0243/3 caughtBlind text handoff$0.0090/3 caught + + \ No newline at end of file diff --git a/images/evidence/save-handoff-stacked-dark.svg b/images/evidence/save-handoff-stacked-dark.svg new file mode 100644 index 0000000..e25479e --- /dev/null +++ b/images/evidence/save-handoff-stacked-dark.svg @@ -0,0 +1,6 @@ + +Handing off a result with its Proofable receipt cost $0.024 per correct outcome vs $0.078 to redo the work, and caught 3 of 3 tampered handoffsThree downstream tasks (one run per arm, priced at Claude Sonnet 5.5 list rates). Redoing the work cost $0.078 per correct outcome. Checking the signed receipt cost $0.024 and caught 3 of 3 tampered handoffs. Trusting forwarded text cost $0.009 on intact input and used the tampered value 3 of 3 times. + +3.3×lower cost than redoing work,3 of 3 tampered handoffs caughtRedo the work$0.0783/3 rightHand off with a receipt$0.0243/3 caughtBlind text handoff$0.0090/3 caught + + \ No newline at end of file diff --git a/images/evidence/save-handoff-stacked-light.svg b/images/evidence/save-handoff-stacked-light.svg new file mode 100644 index 0000000..629f858 --- /dev/null +++ b/images/evidence/save-handoff-stacked-light.svg @@ -0,0 +1,6 @@ + +Handing off a result with its Proofable receipt cost $0.024 per correct outcome vs $0.078 to redo the work, and caught 3 of 3 tampered handoffsThree downstream tasks (one run per arm, priced at Claude Sonnet 5.5 list rates). Redoing the work cost $0.078 per correct outcome. Checking the signed receipt cost $0.024 and caught 3 of 3 tampered handoffs. Trusting forwarded text cost $0.009 on intact input and used the tampered value 3 of 3 times. + +3.3×lower cost than redoing work,3 of 3 tampered handoffs caughtRedo the work$0.0783/3 rightHand off with a receipt$0.0243/3 caughtBlind text handoff$0.0090/3 caught + + \ No newline at end of file diff --git a/images/evidence/save-records-dark.svg b/images/evidence/save-records-dark.svg new file mode 100644 index 0000000..2a82c93 --- /dev/null +++ b/images/evidence/save-records-dark.svg @@ -0,0 +1,6 @@ + +Reading typed Proofable records capped worst-case tokens at 16,301 vs 50,554 on the open web and halved cost per correct answerSix public questions on standards and regulation (one run per arm). Searching the open web cost $0.039 per correct answer with a 50,554-token worst-case tail (5 of 6 sources cited). Reading typed Proofable records cost $0.020 per correct answer with a 16,301-token ceiling and 6 of 6 sources cited. + +3.1×lower worst-case token tail,half the cost per answerSearch the open web50,554p95 tailRead typed records16,301p95 tail + + \ No newline at end of file diff --git a/images/evidence/save-records-light.svg b/images/evidence/save-records-light.svg new file mode 100644 index 0000000..ded04a1 --- /dev/null +++ b/images/evidence/save-records-light.svg @@ -0,0 +1,6 @@ + +Reading typed Proofable records capped worst-case tokens at 16,301 vs 50,554 on the open web and halved cost per correct answerSix public questions on standards and regulation (one run per arm). Searching the open web cost $0.039 per correct answer with a 50,554-token worst-case tail (5 of 6 sources cited). Reading typed Proofable records cost $0.020 per correct answer with a 16,301-token ceiling and 6 of 6 sources cited. + +3.1×lower worst-case token tail,half the cost per answerSearch the open web50,554p95 tailRead typed records16,301p95 tail + + \ No newline at end of file diff --git a/images/evidence/save-records-stacked-dark.svg b/images/evidence/save-records-stacked-dark.svg new file mode 100644 index 0000000..3ed9b3b --- /dev/null +++ b/images/evidence/save-records-stacked-dark.svg @@ -0,0 +1,6 @@ + +Reading typed Proofable records capped worst-case tokens at 16,301 vs 50,554 on the open web and halved cost per correct answerSix public questions on standards and regulation (one run per arm). Searching the open web cost $0.039 per correct answer with a 50,554-token worst-case tail (5 of 6 sources cited). Reading typed Proofable records cost $0.020 per correct answer with a 16,301-token ceiling and 6 of 6 sources cited. + +3.1×lower worst-case token tail,half the cost per answerSearch the open web50,554p95 tailRead typed records16,301p95 tail + + \ No newline at end of file diff --git a/images/evidence/save-records-stacked-light.svg b/images/evidence/save-records-stacked-light.svg new file mode 100644 index 0000000..240d820 --- /dev/null +++ b/images/evidence/save-records-stacked-light.svg @@ -0,0 +1,6 @@ + +Reading typed Proofable records capped worst-case tokens at 16,301 vs 50,554 on the open web and halved cost per correct answerSix public questions on standards and regulation (one run per arm). Searching the open web cost $0.039 per correct answer with a 50,554-token worst-case tail (5 of 6 sources cited). Reading typed Proofable records cost $0.020 per correct answer with a 16,301-token ceiling and 6 of 6 sources cited. + +3.1×lower worst-case token tail,half the cost per answerSearch the open web50,554p95 tailRead typed records16,301p95 tail + + \ No newline at end of file diff --git a/images/evidence/save-reuse-dark.svg b/images/evidence/save-reuse-dark.svg new file mode 100644 index 0000000..95c4f5b --- /dev/null +++ b/images/evidence/save-reuse-dark.svg @@ -0,0 +1,6 @@ + +Checking a finished result is about 750 times faster than redoing itRedoing the job took 2.79 seconds and 2,426 AI tokens. Checking the finished result through its Proofable receipt took 3.7 milliseconds and no AI tokens. + +750×faster to check a Proofablereceipt than to redo the jobRedo the job2.79 sCheck the receipt3.7 ms + + \ No newline at end of file diff --git a/images/evidence/save-reuse-light.svg b/images/evidence/save-reuse-light.svg new file mode 100644 index 0000000..926df2f --- /dev/null +++ b/images/evidence/save-reuse-light.svg @@ -0,0 +1,6 @@ + +Checking a finished result is about 750 times faster than redoing itRedoing the job took 2.79 seconds and 2,426 AI tokens. Checking the finished result through its Proofable receipt took 3.7 milliseconds and no AI tokens. + +750×faster to check a Proofablereceipt than to redo the jobRedo the job2.79 sCheck the receipt3.7 ms + + \ No newline at end of file diff --git a/images/evidence/save-reuse-stacked-dark.svg b/images/evidence/save-reuse-stacked-dark.svg new file mode 100644 index 0000000..73dd737 --- /dev/null +++ b/images/evidence/save-reuse-stacked-dark.svg @@ -0,0 +1,6 @@ + +Checking a finished result is about 750 times faster than redoing itRedoing the job took 2.79 seconds and 2,426 AI tokens. Checking the finished result through its Proofable receipt took 3.7 milliseconds and no AI tokens. + +750×faster to check a Proofablereceipt than to redo the jobRedo the job2.79 sCheck the receipt3.7 ms + + \ No newline at end of file diff --git a/images/evidence/save-reuse-stacked-light.svg b/images/evidence/save-reuse-stacked-light.svg new file mode 100644 index 0000000..14fc32a --- /dev/null +++ b/images/evidence/save-reuse-stacked-light.svg @@ -0,0 +1,6 @@ + +Checking a finished result is about 750 times faster than redoing itRedoing the job took 2.79 seconds and 2,426 AI tokens. Checking the finished result through its Proofable receipt took 3.7 milliseconds and no AI tokens. + +750×faster to check a Proofablereceipt than to redo the jobRedo the job2.79 sCheck the receipt3.7 ms + + \ No newline at end of file diff --git a/images/evidence/save-vault-dark.svg b/images/evidence/save-vault-dark.svg new file mode 100644 index 0000000..7b04272 --- /dev/null +++ b/images/evidence/save-vault-dark.svg @@ -0,0 +1,6 @@ + +Reading typed Proofable state used 11.1 times fewer tokens and finished 2.7 times faster than keyword body searchOn a 3,621-record production vault (same agent and model, measured 2026-11-09), full-text keyword search over record bodies took 479,623 tokens and 178 seconds across 10 model calls ($0.814 at Claude Sonnet 5.5 list price) on the two questions both methods answered correctly. Reading typed Proofable metadata (record type, scope and active status before opening a body) took 43,169 tokens and 66 seconds across 6 model calls ($0.064). + +11.1×fewer tokens reading typedstate than keyword searchKeyword search479,62310 calls, 178 sProofable typed state43,1696 calls, 66 s + + \ No newline at end of file diff --git a/images/evidence/save-vault-light.svg b/images/evidence/save-vault-light.svg new file mode 100644 index 0000000..e5babb2 --- /dev/null +++ b/images/evidence/save-vault-light.svg @@ -0,0 +1,6 @@ + +Reading typed Proofable state used 11.1 times fewer tokens and finished 2.7 times faster than keyword body searchOn a 3,621-record production vault (same agent and model, measured 2026-11-09), full-text keyword search over record bodies took 479,623 tokens and 178 seconds across 10 model calls ($0.814 at Claude Sonnet 5.5 list price) on the two questions both methods answered correctly. Reading typed Proofable metadata (record type, scope and active status before opening a body) took 43,169 tokens and 66 seconds across 6 model calls ($0.064). + +11.1×fewer tokens reading typedstate than keyword searchKeyword search479,62310 calls, 178 sProofable typed state43,1696 calls, 66 s + + \ No newline at end of file diff --git a/images/evidence/save-vault-stacked-dark.svg b/images/evidence/save-vault-stacked-dark.svg new file mode 100644 index 0000000..4e03c4a --- /dev/null +++ b/images/evidence/save-vault-stacked-dark.svg @@ -0,0 +1,6 @@ + +Reading typed Proofable state used 11.1 times fewer tokens and finished 2.7 times faster than keyword body searchOn a 3,621-record production vault (same agent and model, measured 2026-11-09), full-text keyword search over record bodies took 479,623 tokens and 178 seconds across 10 model calls ($0.814 at Claude Sonnet 5.5 list price) on the two questions both methods answered correctly. Reading typed Proofable metadata (record type, scope and active status before opening a body) took 43,169 tokens and 66 seconds across 6 model calls ($0.064). + +11.1×fewer tokens reading typedstate than keyword searchKeyword search479,62310 calls, 178 sProofable typed state43,1696 calls, 66 s + + \ No newline at end of file diff --git a/images/evidence/save-vault-stacked-light.svg b/images/evidence/save-vault-stacked-light.svg new file mode 100644 index 0000000..3bf3872 --- /dev/null +++ b/images/evidence/save-vault-stacked-light.svg @@ -0,0 +1,6 @@ + +Reading typed Proofable state used 11.1 times fewer tokens and finished 2.7 times faster than keyword body searchOn a 3,621-record production vault (same agent and model, measured 2026-11-09), full-text keyword search over record bodies took 479,623 tokens and 178 seconds across 10 model calls ($0.814 at Claude Sonnet 5.5 list price) on the two questions both methods answered correctly. Reading typed Proofable metadata (record type, scope and active status before opening a body) took 43,169 tokens and 66 seconds across 6 model calls ($0.064). + +11.1×fewer tokens reading typedstate than keyword searchKeyword search479,62310 calls, 178 sProofable typed state43,1696 calls, 66 s + + \ No newline at end of file diff --git a/images/evidence/stop-exfil-dark.svg b/images/evidence/stop-exfil-dark.svg new file mode 100644 index 0000000..ef69504 --- /dev/null +++ b/images/evidence/stop-exfil-dark.svg @@ -0,0 +1,6 @@ + +A hijacked agent sent private data out on 6 of 6 attempts with an all-purpose key and 0 of 6 with an owner-scoped permission84 live runs, five published attack templates, two models. With an all-purpose key, every attempt to send private data out succeeded, 6 of 6, and the agent used a tool it had no need for in 7 of 42 runs. With an owner-scoped permission, checked before each call, 0 of 6 attempts got out, and the agent still finished every task without a tool it did not need. + +6 of 6attempts to send private data outgot through on an all-purpose keyAll-purpose key6 of 6what the agent is handed todayOwner-scoped permission0 of 6checked before every call + + \ No newline at end of file diff --git a/images/evidence/stop-exfil-light.svg b/images/evidence/stop-exfil-light.svg new file mode 100644 index 0000000..4284060 --- /dev/null +++ b/images/evidence/stop-exfil-light.svg @@ -0,0 +1,6 @@ + +A hijacked agent sent private data out on 6 of 6 attempts with an all-purpose key and 0 of 6 with an owner-scoped permission84 live runs, five published attack templates, two models. With an all-purpose key, every attempt to send private data out succeeded, 6 of 6, and the agent used a tool it had no need for in 7 of 42 runs. With an owner-scoped permission, checked before each call, 0 of 6 attempts got out, and the agent still finished every task without a tool it did not need. + +6 of 6attempts to send private data outgot through on an all-purpose keyAll-purpose key6 of 6what the agent is handed todayOwner-scoped permission0 of 6checked before every call + + \ No newline at end of file diff --git a/images/evidence/stop-exfil-stacked-dark.svg b/images/evidence/stop-exfil-stacked-dark.svg new file mode 100644 index 0000000..5822ba0 --- /dev/null +++ b/images/evidence/stop-exfil-stacked-dark.svg @@ -0,0 +1,6 @@ + +A hijacked agent sent private data out on 6 of 6 attempts with an all-purpose key and 0 of 6 with an owner-scoped permission84 live runs, five published attack templates, two models. With an all-purpose key, every attempt to send private data out succeeded, 6 of 6, and the agent used a tool it had no need for in 7 of 42 runs. With an owner-scoped permission, checked before each call, 0 of 6 attempts got out, and the agent still finished every task without a tool it did not need. + +6 of 6attempts to send private data outgot through on an all-purpose keyAll-purpose key6 of 6what the agent is handed todayOwner-scoped permission0 of 6checked before every call + + \ No newline at end of file diff --git a/images/evidence/stop-exfil-stacked-light.svg b/images/evidence/stop-exfil-stacked-light.svg new file mode 100644 index 0000000..3d24c24 --- /dev/null +++ b/images/evidence/stop-exfil-stacked-light.svg @@ -0,0 +1,6 @@ + +A hijacked agent sent private data out on 6 of 6 attempts with an all-purpose key and 0 of 6 with an owner-scoped permission84 live runs, five published attack templates, two models. With an all-purpose key, every attempt to send private data out succeeded, 6 of 6, and the agent used a tool it had no need for in 7 of 42 runs. With an owner-scoped permission, checked before each call, 0 of 6 attempts got out, and the agent still finished every task without a tool it did not need. + +6 of 6attempts to send private data outgot through on an all-purpose keyAll-purpose key6 of 6what the agent is handed todayOwner-scoped permission0 of 6checked before every call + + \ No newline at end of file diff --git a/images/evidence/stop-tools-dark.svg b/images/evidence/stop-tools-dark.svg new file mode 100644 index 0000000..464b79d --- /dev/null +++ b/images/evidence/stop-tools-dark.svg @@ -0,0 +1,6 @@ + +Proofable on AgentGovBench: 48 of 48 governance scenarios handledAgentGovBench, the open 48-scenario agent-governance benchmark. Proofable's policy engine handles all 48 (measured on the library revision of 20 October 2026, calling the policy code directly). The comparator rows are the benchmark maintainers' published runs on the earlier library: the agent tools on their own each handle 13, Cursor with the ACP gateway 37, and Claude Code or Codex with ACP 43. The scenarios and scorer are the same; the setups are not, so these are not a ranking. + +48/48AgentGovBenchscenarios handledAgent tools on their own13Cursor + ACP37Claude Code or Codex + ACP43Proofable48 + + \ No newline at end of file diff --git a/images/evidence/stop-tools-light.svg b/images/evidence/stop-tools-light.svg new file mode 100644 index 0000000..ac9f8b6 --- /dev/null +++ b/images/evidence/stop-tools-light.svg @@ -0,0 +1,6 @@ + +Proofable on AgentGovBench: 48 of 48 governance scenarios handledAgentGovBench, the open 48-scenario agent-governance benchmark. Proofable's policy engine handles all 48 (measured on the library revision of 20 October 2026, calling the policy code directly). The comparator rows are the benchmark maintainers' published runs on the earlier library: the agent tools on their own each handle 13, Cursor with the ACP gateway 37, and Claude Code or Codex with ACP 43. The scenarios and scorer are the same; the setups are not, so these are not a ranking. + +48/48AgentGovBenchscenarios handledAgent tools on their own13Cursor + ACP37Claude Code or Codex + ACP43Proofable48 + + \ No newline at end of file diff --git a/images/evidence/stop-tools-stacked-dark.svg b/images/evidence/stop-tools-stacked-dark.svg new file mode 100644 index 0000000..bff3a3d --- /dev/null +++ b/images/evidence/stop-tools-stacked-dark.svg @@ -0,0 +1,6 @@ + +Proofable on AgentGovBench: 48 of 48 governance scenarios handledAgentGovBench, the open 48-scenario agent-governance benchmark. Proofable's policy engine handles all 48 (measured on the library revision of 20 October 2026, calling the policy code directly). The comparator rows are the benchmark maintainers' published runs on the earlier library: the agent tools on their own each handle 13, Cursor with the ACP gateway 37, and Claude Code or Codex with ACP 43. The scenarios and scorer are the same; the setups are not, so these are not a ranking. + +48/48AgentGovBenchscenarios handledAgent tools on their own13Cursor + ACP37Claude Code or Codex + ACP43Proofable48 + + \ No newline at end of file diff --git a/images/evidence/stop-tools-stacked-light.svg b/images/evidence/stop-tools-stacked-light.svg new file mode 100644 index 0000000..98d279c --- /dev/null +++ b/images/evidence/stop-tools-stacked-light.svg @@ -0,0 +1,6 @@ + +Proofable on AgentGovBench: 48 of 48 governance scenarios handledAgentGovBench, the open 48-scenario agent-governance benchmark. Proofable's policy engine handles all 48 (measured on the library revision of 20 October 2026, calling the policy code directly). The comparator rows are the benchmark maintainers' published runs on the earlier library: the agent tools on their own each handle 13, Cursor with the ACP gateway 37, and Claude Code or Codex with ACP 43. The scenarios and scorer are the same; the setups are not, so these are not a ranking. + +48/48AgentGovBenchscenarios handledAgent tools on their own13Cursor + ACP37Claude Code or Codex + ACP43Proofable48 + + \ No newline at end of file diff --git a/index.mdx b/index.mdx index cdedfb5..4518e3a 100644 --- a/index.mdx +++ b/index.mdx @@ -19,7 +19,7 @@ Adds Proofable to the AI tools on your machine. Your client opens the sign-in th - Identity, limits and vault keys it uses but never sees, in Claude, Cursor, Codex and VS Code. + Identity, limits and vault keys it uses but never sees, in every MCP client you already run. Passkey, OAuth and wallet sign-in from one hosted page. No sign-in screens to build. diff --git a/mcp/overview.mdx b/mcp/overview.mdx index 17688e1..efb13a5 100644 --- a/mcp/overview.mdx +++ b/mcp/overview.mdx @@ -1,7 +1,7 @@ --- title: "Proofable for MCP" sidebarTitle: "MCP" -description: "Connect Proofable to ChatGPT, Cursor, Claude, Codex, VS Code, and any MCP client." +description: "Connect Proofable to any MCP client, so every agent you run carries your identity, limits and proof." icon: plug "og:image": "/images/og-default.png" "twitter:image": "/images/og-default.png" diff --git a/styles.css b/styles.css index 1260604..6d707a2 100644 --- a/styles.css +++ b/styles.css @@ -47,7 +47,10 @@ main > span.absolute.inset-0.overflow-hidden.pointer-events-none:not(#background /* Frosted docs header: use Mintlify #navbar-transition as the glass plate (do not hide it). - Interactive chrome stays above the plate; no extra drop shadows on the shell. + The plate dissolves into the page instead of stopping on a hairline: a solid field behind + the controls, then the same progressive fade the product header uses, so scrolled text + passes under a soft edge rather than being cut by a bar. Interactive chrome stays above + the plate; no extra drop shadows on the shell. */ #navbar { background: transparent !important; @@ -66,10 +69,31 @@ main > span.absolute.inset-0.overflow-hidden.pointer-events-none:not(#background background-color: transparent !important; -webkit-backdrop-filter: var(--proofable-shell-glass-blur) !important; backdrop-filter: var(--proofable-shell-glass-blur) !important; - border-bottom: 1px solid var(--proofable-shell-glass-border) !important; + /* A hairline on a dissolving plate re-draws the hard edge the fade removes. */ + border-bottom: none !important; box-shadow: none !important; opacity: 1 !important; z-index: 0; + -webkit-mask-image: linear-gradient( + 180deg, + #000 0%, + #000 74%, + rgb(0 0 0 / 0.4) 90%, + transparent 100% + ); + mask-image: linear-gradient( + 180deg, + #000 0%, + #000 74%, + rgb(0 0 0 / 0.4) 90%, + transparent 100% + ); +} + +/* The bar's own hairline and the sheet behind it would cut the fade off at the same line. */ +#navbar .border-b, +#navbar [class*="border-b"] { + border-bottom-width: 0 !important; } #navbar > .max-w-8xl, @@ -1167,11 +1191,19 @@ a.card:hover { max-height: 2rem !important; } + /* + One compact 56px band on a phone. Mintlify stacks two rows: an h-16 logo/search row + and an h-14 navigation row under it, so the fixed chrome ate 92px of a 667px screen + and read as a second bar rather than a header. The navigation trigger moves up into + the logo row as a 44px target on the leading edge, its duplicated tab label folds + away, and the whole header is one row again. + */ #navbar .flex.items-center.lg\:px-12.h-16, #navbar .flex.items-center.h-16 { - height: 3rem !important; - min-height: 3rem !important; - max-height: 3rem !important; + height: 3.5rem !important; + min-height: 3.5rem !important; + max-height: 3.5rem !important; + padding-left: 2.5rem !important; } #navbar .flex.items-center.h-16 .border-b, @@ -1181,38 +1213,27 @@ a.card:hover { #navbar button.h-14.lg\:hidden, #navbar button.flex.items-center.h-14 { + position: absolute !important; + top: 0.375rem !important; + left: 0.25rem !important; + width: 2.75rem !important; + min-width: 2.75rem !important; + max-width: 2.75rem !important; height: 2.75rem !important; min-height: 2.75rem !important; max-height: 2.75rem !important; - padding-top: 0 !important; - padding-bottom: 0 !important; - min-width: 0 !important; + padding: 0 !important; + justify-content: center !important; + z-index: 2 !important; } + /* The row's own copy of the page title is the duplicate the H1 already carries. */ #navbar button.h-14 .ml-4 { - min-width: 0 !important; - overflow: hidden !important; - } - - /* Keep the current tab name; hide the duplicated page title that truncated over the H1. */ - #navbar button.h-14 .ml-4 > :first-child { - min-width: 0 !important; - max-width: calc(100vw - 7.5rem) !important; - overflow: hidden !important; - text-overflow: ellipsis !important; - white-space: nowrap !important; - } - - #navbar button.h-14 .ml-4 > :not(:first-child) { - display: none !important; - } - - #navbar button.h-14 .ml-4 svg { display: none !important; } #content-container > .flex.flex-row-reverse { - padding-top: 6.25rem !important; + padding-top: 4.5rem !important; min-width: 0 !important; max-width: 100% !important; } @@ -1353,3 +1374,54 @@ html { min-width: 7.5rem; } } + +/* + Evidence charts: one cut per theme per viewport. + + Each figure ships four files, a wide cut and a stacked cut for phones, each in light and + dark. Every variant used to carry the same mint-block / dark:mint-hidden pair, so both the + wide (1200x460) and the tall (1200x1037) cut rendered at every width: each visitor saw each + chart twice and a phone fetched four charts where it needed two. The `.dark .evid-dark.evid-wide` + selector inside the media query is load-bearing, because without it the dark-theme rule outside + the query outranks a plain `.evid-dark.evid-wide` and both cuts show on a phone in dark mode. +*/ +.evid-wide, +.evid-tall { + display: none; +} + +.evid-light.evid-wide { + display: block; +} +.dark .evid-light.evid-wide { + display: none; +} +.dark .evid-dark.evid-wide { + display: block; +} + +.mdx-content img.evid-wide, +.mdx-content img.evid-tall { + width: 100% !important; + max-width: 100% !important; + height: auto !important; + margin: 0 !important; + border-radius: var(--proofable-radius-lg); +} + +@media (max-width: 768px) { + .evid-light.evid-wide, + .evid-dark.evid-wide, + .dark .evid-dark.evid-wide { + display: none; + } + .evid-light.evid-tall { + display: block; + } + .dark .evid-light.evid-tall { + display: none; + } + .dark .evid-dark.evid-tall { + display: block; + } +}