README.md

metadata

title: TrustStack Console
emoji: 🌍
colorFrom: yellow
colorTo: purple
sdk: gradio
sdk_version: 6.2.0
app_file: app.py
pinned: false
license: other
short_description: infrastructure, not a toy.
thumbnail: >-
  https://cdn-uploads.huggingface.co/production/uploads/685edcb04796127b024b4805/05XC45vRZzru1-cBEWeVN.png

RFTSystems — TrustStack Console

I don’t do “trust me”. I do receipts.

TrustStack Console is a single, clean demo of what “agent infrastructure” should look like when you care about auditability, integrity, and cost control. It combines durable local memory, fast retrieval, tamper-evident logging, per-turn receipts, verification, guardrails, trace artifacts, and one-click audit exports.

Space: https://huggingface.co/spaces/RFTSystems/TrustStack_Console

---

What this is

Most agent stacks can store chat logs. That is not the problem.

The problem is provable influence:

• What memory did the agent actually retrieve?
• What evidence influenced the output?
• Can you prove the record wasn’t edited after the fact?
• Can you export a defensible audit bundle?

TrustStack answers those questions with:

• Append-only ledger (events stored as JSONL)
• Hash chain integrity (tamper-evident session history)
• SQLite FTS retrieval (fast lexical recall, no embeddings required)
• Per-turn Memory Receipts (downloadable proof of retrieval + hashes)
• Receipt verification (pass/fail)
• Receipt-gated tool execution (guardrails)
• Trace export (OTel-style trace artifact JSON)
• Audit pack export (ZIP bundle of ledger + receipts + integrity summary)
• Token budget calculator (why fixed retrieval beats replaying history)

---

How it works (in plain terms)

1. Every message becomes an event appended to the session ledger.
2. Each event is hashed (digest) and chained to the previous event (chain_hash).
3. Retrieval uses SQLite FTS5 over stored text.
4. Every assistant turn produces a receipt containing:
   • the query
   • the retrieved event slices
   • each slice’s digest + chain hash
   • prompt hash + response hash
5. Receipt verification checks that all referenced events exist and that hashes match the stored ledger.

If someone edits history, the chain breaks. Verification fails. Loudly.

---

Tabs

Investor Demo

One click, full story: store → retrieve → override → generate receipt → verify → export trace → export audit pack.

Chat

Live interaction. Stores every turn, retrieves relevant memory slices, generates receipts.

Verify Receipt

Upload a receipt JSON and get a pass/fail integrity check.

Guardrails

A tool call is blocked unless a supplied receipt verifies. This demonstrates “execution only when evidence checks out”.

Trace Export

Each turn produces an OTel-style trace JSON artifact showing what was retrieved and what hashes were produced.

Audit Pack

One-click ZIP export: ledger + receipts + integrity summary.

API Playground

JSON-in / JSON-out “tool style” calls (write, search, verify, export) for developers.

Token Budget

Shows why fixed retrieval budgets scale better than replaying full history.

---

Quick demo prompts (copy/paste)

1. Store facts:

• Store these exactly: Dog=Nova, City=Manchester, Drink=Pepsi Max.

2. Recall:

• What is my dog's name?
• What city did I say?

3. Override:

• My drink is Coke Zero now. This overrides earlier.
• What is my favourite drink?

4. Search:

• Search for: Nova
• Search for: Manchester

Then:

• Download the receipt JSON
• Upload it into Verify Receipt
• Edit one character inside the receipt and verify again (it should fail)

That pass/fail behaviour is the point.

---

API Playground examples

memory.write

{
  "role": "user",
  "text": "Store this: Dog=Nova, City=Manchester."
}
memory.search
json
Copy code
{
  "query": "Nova",
  "k": 8
}
receipt.verify
Paste the full receipt JSON under:

json
Copy code
{
  "receipt": { ... }
}
audit.export
json
Copy code
{}
Persistence
By default the store uses:

var/rftmem (relative path)

You can set a base directory with:

RFT_MEM_BASE=/your/persistent/path

On hosted environments, persistent storage is what turns this into genuine “restart continuity”.

Run locally
bash
Copy code
pip install -U gradio
python app.py
Then open the printed local URL.

Why this matters
If you’re building agents for real users, you need more than “it usually works”:

Debuggability: show exactly what influenced a decision.

Safety: block actions unless evidence verifies.

Compliance readiness: export a bundle you can actually defend.

Cost control: retrieve a fixed budget instead of replaying history forever.

TrustStack is a working demo of that philosophy: memory you can audit, not memory you’re told to believe.

Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference