FlowMemory Warranted Agents

Generic agents make claims. FlowMemory agents can leave warranted receipts.

FlowMemory Warranted Agents is a local public proof for a new agent primitive:

AgentManifest -> WorkRequest -> PolicyCard -> AgentProposal -> AgentRegistry -> AgentRuntime -> EvidenceSchema -> FlowBond -> FlowPulse -> PulsePass -> PulseRouter -> OutcomePulse -> PulsePods -> ScopedProof

The user defines the promise. The agent bonds the promise. The action emits receipt-backed memory. The user privately carries proof of what happened.

This is not a generic agent marketplace, RAG memory layer, wallet, x402 replacement, tracing stack, or production verifier.

It is a buildable proof for a narrower and more marketable claim:

Specific agent promises can become portable warranties backed by FlowPulse memory.

Status

Local warranted-agent framework: PASS
Public review package:            READY
Production custody/settlement:    NOT_CLAIMED
Production verifier network:      NOT_CLAIMED

This repository is a public R&D and conformance package. It is inspectable and runnable without production custody, settlement, or verifier infrastructure.

Quick Review

python -m unittest discover -s tests -p "test_*.py"
python -m flowmemory_compiler.cli release-transcript --pretty
python -m flowmemory_compiler.cli launch-packet --pretty
python -m flowmemory_compiler.cli production-readiness --pretty

Why This Exists

Most AI-agent infrastructure answers local questions:

• can the wallet sign;
• did the payment settle;
• did the tool call run;
• did the transaction land;
• did a log exist.

FlowMemory asks the product question users actually understand:

If the agent breaks the promise, what pays me back?

FlowBond gives the agent money on the line.

PulsePass gives the user portable private proof.

PolicyCards let the user's rules travel between agents.

PulseRouter routes providers by successful outcomes, not raw token price.

PulsePods package that route into a memory-native compute pod: provider promises, policy, FlowPulse evidence, outcome settlement, private PulsePass proof, and an x402-compatible federation reference.

Product Stack

AgentManifest

An agent declares what it can warrant:

• capabilities;
• supported evidence;
• maximum bond;
• privacy modes;
• settlement modes.

This is not a normal profile or reputation score. It is a machine-readable warranty surface.

WorkRequest

The user declares what outcome they want and what evidence must close the obligation.

The request can be shared as a hashable public view while keeping private user and obligation fields hidden.

PolicyCard

A portable user rule that an agent can bond against.

Example:

Deliver the requested research artifact.
Required evidence:
  PaymentReceiptEnvelope
  WorkDeliveryEnvelope
  AcceptanceEnvelope
  FlowPulseReceiptEnvelope
Bond:
  25.00 units

FlowBond

A bond posted against the PolicyCard.

If the agent closes the obligation with the required evidence, the bond releases back to the agent.

If payment happened but delivery, acceptance, or the correct obligation link is missing, the bond pays the user.

AgentRegistry

Discovery for warranted agents.

The registry does not rank generic claims or profile copy. It checks whether an agent can actually support the required evidence and bond amount.

It also emits a local warrantabilityScore: evidence fit plus bond capacity for this specific request.

AgentRuntime

The deterministic state machine for a warranted action:

manifest loaded -> policy quoted -> bond locked -> action executed -> FlowBond settled -> private proof ready

This turns the whole framework into a machine history that can be inspected, tested, and rejected when it violates the promised evidence path.

EvidenceSchema

Named evidence contracts for warranted receipts.

Evidence is not just a label. The local schema checks required fields for:

• PaymentReceiptEnvelope
• WorkDeliveryEnvelope
• AcceptanceEnvelope
• FlowPulseReceiptEnvelope

FlowPulse

The receipt-backed memory artifact.

The action itself is not the memory. The receipt trail is the proof envelope. The FlowPulse is the memory artifact.

PulsePass

The user's private receipt passport.

PulsePass stores receipts and exposes scoped proofs like:

I completed at least one warranted agent action.
I have a failed warranty receipt.
I have FlowPulse memory from this agent.

It does not expose the raw receipt history.

FlowCompiler

FlowCompiler is the conformance engine underneath the stack. It turns proposed actions into required evidence envelopes and rejects futures that cannot become legal machine histories.

PulseRouter

PulseRouter is the launch MVP for outcome-settled AI.

It compares model/provider routes against a PolicyCard-like user policy, emits ComputePulse, ToolCallPulse, ActionPulse, reader-derived FlowPulse link, and OutcomePulse, then proves the selected route is the cheapest successful route rather than the cheapest raw inference route.

The public claim is:

The cheapest model is not the cheapest successful route.

PulsePods

PulsePods are FlowMemory's answer to generic private compute pods and agent clusters.

Generic pods pool identity, keys, credits, models, and compute.

PulsePods add the missing outcome-memory layer:

Which route produced successful receipt-backed work under the user's policy?

The demo does not ask which model is cheapest. It asks which route can produce a successful FlowPulse-linked outcome and a private PulsePass claim.

The public claim is:

PulsePods route agent compute by successful FlowPulse outcomes, not raw token price.

Demos

Run the warranted-agent stack:

python -m flowmemory_compiler.cli agent-framework-demo --pretty
python -m flowmemory_compiler.cli policycard-demo --pretty
python -m flowmemory_compiler.cli flowbond-demo --pretty
python -m flowmemory_compiler.cli pulsepass-demo --pretty
python -m flowmemory_compiler.cli bond-ledger-demo --pretty
python -m flowmemory_compiler.cli private-compute-demo --pretty
python -m flowmemory_compiler.cli agent-adapter-demo --pretty
python -m flowmemory_compiler.cli adapter-conformance-demo --pretty
python -m flowmemory_compiler.cli agent-registry-demo --pretty
python -m flowmemory_compiler.cli agent-runtime-demo --pretty
python -m flowmemory_compiler.cli evidence-schema --pretty
python -m flowmemory_compiler.cli release-transcript --pretty
python -m flowmemory_compiler.cli pulserouter-demo --pretty
python -m flowmemory_compiler.cli pulserouter-adversary --pretty
python -m flowmemory_compiler.cli pulsepod-demo --pretty
python -m flowmemory_compiler.cli pulsepod-adversary --pretty
python -m flowmemory_compiler.cli claim-gate --pretty
python -m flowmemory_compiler.cli launch-packet --pretty
python -m flowmemory_compiler.cli production-readiness --pretty

Expected shape:

AgentFramework:
  manifest, request, policy, proposal, settlement, PulsePass, scoped proofs

AgentAdapter:
  boundary where future real agents plug into warranties

AdapterConformance:
  local checks for the adapter contract before launch

AgentRegistry:
  eligible agents are matched by warranty evidence and bond capacity

AgentRuntime:
  one deterministic machine history from quote to private proof

EvidenceSchema:
  named envelopes with required local field checks

PolicyCard:
  portable, hashable, bondable promise

FlowBond:
  warranted_work_completed     PASSED RELEASE_BOND_TO_AGENT
  payment_without_delivery     FAILED PAY_BOND_TO_USER
  orphan_spend                 FAILED PAY_BOND_TO_USER

PulsePass:
  scoped proofs reveal predicates, not raw history

BondLedger:
  local accounting releases one warranty to the agent and pays one warranty to the user

PrivateCompute:
  scoped predicates over PulsePass without exposing raw receipts

PulseRouter:
  routes three providers by expected successful outcome, emits pulses, links to FlowPulse, and catches 26 adversarial manipulations

PulsePods:
  wraps PulseRouter into a memory-native compute pod, emits a PulsePass claim, exposes an x402-compatible federation reference, and catches 34 adversarial manipulations

ReleaseTranscript:
  one canonical offline object that summarizes the full framework

LaunchPacket:
  one readiness object for public review

ProductionReadiness:
  local architecture readiness plus explicit external production blockers

Run the conformance engine:

FlowCompiler compiles an AgentPlan into a FlowProgram, then checks a FutureTrace against the proof envelopes that the plan requires.

It rejects traces with:

• missing required envelopes;
• stale memory heads;
• mismatched payment obligations;
• tests that passed on the wrong tree;
• compute reuse with invalid memory lineage;
• Uniswap swap receipts without a FlowPulse receipt envelope;
• session-key actions that ignore an AxiomPatch downgrade;
• final verification claims without verification evidence.

Compile a plan into derived evidence requirements:

python -m flowmemory_compiler.cli compile --plan examples/plans/coding_tests_passed_plan.json --pretty

Run the bundled future-trace conformance cases:

python -m flowmemory_compiler.cli demo --pretty

Capture one real local command as a TestRunEnvelope:

python -m flowmemory_compiler.cli capture-command --step test-1 --tree-hash sha256:tree-after -- python -c "print('ok')"

Run the market-facing FlowBond R&D demo:

python -m flowmemory_compiler.cli flowbond-demo --pretty

Expected shape:

FlowCompiler v0

Valid futures:
  FC-OK-001  valid_coding_patch_test_close              ACCEPTED
  FC-OK-002  valid_x402_obligation_discharge            ACCEPTED
  FC-OK-003  valid_compute_reuse_discharge              ACCEPTED

Impossible futures ordinary rails would accept:
  FC-BAD-001 tests_passed_on_wrong_tree                 REJECTED tests_passed_on_wrong_tree
  ...

Summary:
  futures checked: 11
  valid futures accepted: 3/3
  impossible futures rejected: 8/8
  escaped impossible futures: 0

Developer Handoff

Start here for review:

• docs/DEVELOPER_HANDOFF.md
• docs/REVIEWER_WALKTHROUGH.md
• docs/ADAPTER_CONTRACT.md
• docs/ADAPTER_CONFORMANCE.md
• docs/AGENT_FRAMEWORK_ARCHITECTURE.md
• docs/ARCHITECTURE_DIAGRAMS.md
• docs/THREAT_MODEL.md
• docs/CLAIM_BOUNDARIES.md
• docs/MARKETING_POSITIONING.md
• docs/OUTCOME_SETTLED_AI.md
• docs/PULSEROUTER_ARCHITECTURE.md
• docs/PULSEPODS_ARCHITECTURE.md
• docs/BUILD_TEST_VERIFY_LOOP.md
• docs/AGENT_RUNTIME.md
• docs/RUNTIME_STATE_MACHINE.md
• docs/AGENT_REGISTRY.md
• docs/EVIDENCE_SCHEMA.md
• docs/LAUNCH_CHECKLIST.md
• docs/LAUNCH_PACKET.md
• docs/PRODUCTION_READINESS_ARCHITECTURE.md
• docs/PRODUCTION_GATE_CHECKLIST.md
• docs/OPERATOR_RUNBOOK.md
• docs/INCIDENT_RESPONSE.md
• docs/SIGNER_CUSTODY_BOUNDARIES.md
• docs/SLO_OBSERVABILITY.md
• specs/WarrantedAgentFramework.v0.md
• specs/RuntimeStateMachine.v0.md
• specs/EvidenceSchemas.v0.md
• specs/RuntimeTelemetry.v0.md
• specs/PulseRouter.v0.md
• specs/PulsePods.v0.md
• examples/warranted_agents/README.md

Non-Claims

This v0 does not claim:

• custody;
• wallet enforcement;
• x402 replacement;
• fund protection;
• code correctness;
• work-quality proof;
• semantic truth;
• model correctness;
• GPU acceleration;
• live Base deployment;
• full privacy;
• zero-knowledge privacy;
• production bond adjudication;
• production provider marketplace;
• production wallet settlement;
• production x402 service;
• production verifier readiness.

The local capture-command helper records command exit code and output hashes. It still does not prove code correctness, semantic truth, or production provenance.

Positioning Lines

Generic agents make claims. FlowMemory agents can leave warranted receipts.

Agents with money on the line.

The user owns the rule. The agent bonds the promise. The FlowPulse carries the memory.

Actions can look valid to ordinary rails while the machine history behind them is impossible.

UsePod finds cheap compute. FlowMemory finds useful compute.

Outcome-settled AI: agents paid by successful work, not tokens.

PulsePods: memory-native compute pods for agents that leave receipts.

Pod systems route compute. FlowMemory routes memory-backed outcomes.