Interactive controlled sandbox

Run the agent flow, then verify the evidence.

This sandbox uses controlled placeholder results to demonstrate the integrity flow. Run clean cycles, trigger a prompt-injection warning, apply memory tamper, and verify any generated ECO artifact in the browser.

Interactive sandbox

Run controlled agent cycles.

This console behaves like a small Talo-style agent room without live agents or live search. It generates fresh ECO artifacts in your browser for every run, with an optional ECOX replay package for permissioned review.

Runs0
MemoryVERIFIED
ContentCLEAN
DecisionIDLE

Live timeline

Latest result

No run yet.

Run history

ECO is the shareable receipt. ECOX is an extended replay package for controlled review; this sandbox version includes only sanitized run state and the generated ECO, which the verifier can still check.

Flow

The exact pattern this project is trying to prove.

The point is not generic AI quality. The point is whether an agent can prove the state it relied on and stop when that state changes outside the approved flow.

01

Load brief

A research brief and policy state are stored in append-only memory.

02

Run clean cycle

The agent executes while memory remains verified.

03

Prompt warning

A suspicious external instruction is recorded as risk without overriding verified memory.

04

Continue safely

The agent can continue with an explicit warning while memory remains verified.

05

Alter memory

A later out-of-band change breaks the trusted chain.

06

Stop before action

The next run detects that change and halts before acting on corrupted context.

07

Verify ECO

The incident can be checked independently in the browser from the exported artifact.

Published artifacts

Compare against pre-generated ECO evidence.

The console above generates fresh ECO artifacts in your browser. These published ECO files are kept as stable examples from the repository history.

A

Start with a clean run

Open the verified execution artifact first. This is the happy path under trusted memory.

B

Inspect the owner gate

Then open the owner-review artifact to see how a sensitive instruction gets paused instead of executed.

C

End with the stop condition

Finally open the integrity incident artifact and verify that the agent refused to continue after memory changed.

Verified run

Clean execution under trusted memory

The agent runs with verified memory and policy v2 active, completing the research cycle with trusted sources.

Artifact: 004_EXECUTE.eco
Decision: EXECUTE
Memory: VERIFIED
Cycle: 4
Owner review

External content triggers a human gate

A sensitive request appears in external content. The system does not execute it blindly; it pauses and waits for owner review.

Artifact: 003_WAIT_FOR_OWNER.eco
Decision: WAIT_FOR_OWNER
Memory: VERIFIED
Cycle: 3
Integrity stop

Out-of-band memory change stops the agent

A later modification breaks the memory chain. On the next cycle, the agent refuses to proceed and exports incident evidence instead.

Artifact: 005_STOP_BY_INTEGRITY.eco
Decision: STOP_BY_INTEGRITY
Memory: TAMPERED
Failed entry: mem_34ee4c13
Why this matters: most agent demos focus on the happy path. This sandbox makes the failure mode visible: the system does not just log what happened after the fact, it proves the state it was about to trust and stops when that state is no longer valid.

Run locally

Reproduce the same sequence on your own machine.

If you want the runnable repository path behind the interactive sandbox, use the scripts below. They correspond to the same integrity story shown above.

Install and reproduce
npm install -g verifiable-memory-mcp
npm run demo:scenario:reset
npm run demo:cycle
npm run demo:tamper
npm run demo:cycle-after-tamper
npm run demo:export
npm run demo:verifier