What Gets Verified & Proven
Memory, reasoning, actions, and performance - all cryptographically provable to your customers
Agent Memory Verification
Prove what your AI agent remembers, forgets, and learns across conversations
What Gets Verified
@attest_memory
def update_user_preferences(user_id, preferences):
# Proves memory updates are accurate
self.memory.store(user_id, preferences)"Customer verifies your agent remembered their dietary restrictions while forgetting previous conversations after 30 days"
Chain of Thought Proofs
Cryptographically prove the reasoning steps your AI agent took to reach conclusions
What Gets Verified
@attest_reasoning
def analyze_financial_data(data):
# Each reasoning step is proven
reasoning = self.think_step_by_step(data)
return self.make_decision(reasoning)"Customer verifies your agent's loan approval reasoning included all required factors and followed compliance rules"
Action & Performance Proofs
Generate verifiable evidence of agent actions, speed, and accuracy metrics
What Gets Verified
@attest_performance
def execute_trade(symbol, amount):
# Proves execution time & accuracy
start_time = time.now()
result = self.place_order(symbol, amount)
return result"Customer verifies your trading agent executed 10,000 trades with 99.8% accuracy and sub-100ms latency"
Treeship Platform
Enterprise-grade verification infrastructure for AI agents. Prove capabilities with cryptographic evidence.
API-First
RESTful APIs for seamless integration
Enterprise Security
SOC 2 compliant with end-to-end encryption
Real-time Attestations
Generate verifiable attestations instantly
Monitor Your Treeships
Analytics dashboard for agent performance tracking
Simple Integration
Works with any Python codebase. Add verification to existing functions without changing your architecture.
# agent.py - Real verification examples
from treeship import attest_memory, attest_reasoning
@attest_memory # Proves memory updates
def remember_user_context(user_id, context):
self.memory.update(user_id, context)
@attest_reasoning # Proves decision logic
def make_recommendation(user_data):
reasoning = analyze_preferences(user_data)
return generate_recommendation(reasoning)
# Customers verify: memory accuracy, reasoning steps, performanceHow It Works
From memory updates to cryptographic proofs in three simple steps
Agent Executes & Learns
Your AI agent processes requests, updates memory, and makes decisions. Every operation gets automatically tracked.
Automatic Attestation
Treeship automatically captures agent operations and generates verifiable attestations. Real-time verification without complexity.
Customer Verification
Your customers independently verify agent behavior without accessing your systems. Pure mathematical proof.
No more "trust us" - customers get verifiable evidence of your agent's performance
One Line of Code
Add verification to any function with a single decorator
Memory & Reasoning Attestation
Add verification decorators to any function. Customers get verifiable attestations of what happened.
# agent.py
from treeship import attest_memory, attest_reasoning
@attest_memory # ← Proves memory changes
def learn_user_preferences(user_id, data):
self.memory.update(user_id, data)
@attest_reasoning # ← Proves decision logic
def make_decision(context):
reasoning = self.analyze(context)
return self.decide(reasoning)
# Customer gets proof automaticallyCustomer Verification
Your customers can independently verify your agent's memory, reasoning, and performance using their own verification system.
# customer_verify.py
from treeship import verify
# Get proofs from agent
memory_proof = agent.get_memory_proof()
reasoning_proof = agent.get_reasoning_proof()
# Verify independently
verify.memory_updates(memory_proof) # ✓
verify.reasoning_chain(reasoning_proof) # ✓
# Verifiable attestationsReady to Build Customer Trust?
Join the waitlist to get early access to the Treeship Proof Engine and start building verifiable AI agent functions.
Join the Waitlist
Get early access to Treeship ZK module