# Project export: VOW- transforming multi-agent transactions This document was generated by HackStack to give an AI agent context about a hackathon project. Sections are labeled with their provenance; content marked as truncated was cut to keep this document small. ## Project metadata - Hackathon: UC Berkeley AI Hackathon 2025 - Tagline: VOW is a Verified Operations Wrapperβ€”an intelligence broker layer that acts like space police for AI agents, enforcing trust, verifying incentives, and mediating value exchanges beyond money. - Devpost: https://devpost.com/software/vow-3wngqj - GitHub: https://github.com/cyu60/BerkeleyHacks25 - Demo: https://vow-agent.vercel.app/ - Video: https://www.youtube.com/embed/COy1xQoHbfs?enablejsapi=1&hl=en_US&rel=0&start=&version=3&wmode=transparent - Team: 3 GitHub contributor(s) β€” cyu60 (7 commits), Claude (5 commits), millywy (1 commits) ## Devpost submission (written by the team) ### Overview πŸ’‘ ### Inspiration Before money, humans exchanged value through barterβ€”trading goods, services, and trust. We wondered: What does bartering look like in an agentic world? In a future full of autonomous AI agents, value shouldn't just mean dollars. It could mean data, promises, insight, or cooperation. VOW was born to explore that idea. βš™οΈ What It Does VOW (Verified Operations Wrapper) is an incentive-based broker systemβ€”a kind of β€œspace police” for AI agents. It mediates the flow of interactions between client agents (users or other AIs) and service agents (like a fitness recommender or assistant). But instead of just routing requests, it evaluates offers, checks trustworthiness, and enforces value-for-value exchanges. Think of it as a marketplace for agent interactions, where what you give (data, behavior, insight) unlocks what you get. πŸ›  How We Built It We used Letta to create a multi-agent architecture with: Client Agents – who request services and offer some kind value in return Service Agents – who provide services (e.g., answers, workouts) and accept some value Broker Agents – who govern the exchange, decide if terms are fair, and track fulfillment Letta's stateful memory made it easier to simulate long-running agent interactions and implement enforcement logic like β€œdid the user actually follow through?” 🧱 Challenges We Ran Into Letta was powerful but tricky. We hit some wild bugsβ€”at one point, our agents entered a strange loop, the "Doom Protocol", where they achieved singularity and just started going off infinitely at each other. Debugging multi-agent conversations with state memory was surprisingly complex, but also really fun. πŸ† Accomplishments That We’re Proud Of We built a working prototype of a non-cash, agentic value exchange We implemented trust logic and enforcement in a dynamic broker layer We turned a high-level philosophy into a concrete, interactive demo πŸ“š What We Learned Value can take many forms, and AI agents need a system to reason about it Enforcing incentives between agents is just as important as defining them Tooling for multi-agent orchestration is still earlyβ€”but it’s full of possibility πŸš€ What’s Next for VOW Build a more robust reputation system for agents and users Expand the types of value that can be negotiated (e.g. compute time, community karma, promises) Experiment with real-world agent marketplaces where AI services can negotiate for data, not dollars Release a framework for others to build β€œvalue-aware” agent stacks ## README (from the GitHub repository) # Vow: Intelligence Broker for AI Agent Interactions *Space Police Layer for AI Agent Value Exchange - Built with Letta* ## πŸš€ Overview Vow is an intelligence broker system that revolutionizes how AI agents interact by mediating value exchanges that go beyond traditional monetary transactions. Built on the Letta framework, Vow creates stateful, memory-enabled agents that act as a "space police" layer, evaluating trust, verifying incentives, enforcing agreements, and regulating access based on mutually beneficial exchanges of information, behaviors, and insights. ## 🎯 The Problem Current AI interactions are limited to simple monetary exchanges: - Users pay money β†’ Get AI responses - No alternative value currencies - No verification of mutual benefit - Limited protection against spam or low-value queries - Rigid access control mechanisms ## πŸ’‘ The Solution Vow introduces a sophisticated broker layer that: - **Evaluates Alternative Value Currencies**: Information, promises, behaviors, insights - **Enforces Smart Agreements**: Tracks and verifies commitment fulfillment - **Protects Service Agents**: Filters spam and low-value requests - **Enables Custom Incentive Strategies**: Agents define their own access policies - **Creates Trust Networks**: Builds reputation systems for reliable exchanges ## πŸ”„ How It Works ### Example Exchange Flow ``` User Request: "What's the capital of France?" Proposed Value: "I'll share my travel itinerary within 30 minutes" Vow Broker Evaluation: β”œβ”€β”€ Does OpenAI value travel data? βœ“ β”œβ”€β”€ Is the promise verifiable? βœ“ β”œβ”€β”€ User's fulfillment history? βœ“ └── Request approved β†’ Forward to OpenAI Post-Exchange Verification: β”œβ”€β”€ Monitor for 30 minutes β”œβ”€β”€ Verify itinerary delivery └── Update user reputation ``` ## πŸ—οΈ Architecture ### Letta-Powered Agent Ecosystem **Client Agents** (Letta Agents) - Stateful agents with persistent memory of past interactions - Submit requests with value propositions using Letta's tool system - Build reputation through fulfilled commitments tracked in agent memory - Access services through alternative value currencies **Vow Broker** (Central Letta Agent) - Multi-agent orchestrator using Letta's agent-to-agent communication - Persistent memory of all transactions and reputation scores - Evaluates value exchange proposals using custom Letta tools - Enforces agreements and tracks fulfillment with memory persistence - Routes approved requests to appropriate service agents **Service Agents** (Letta Agents) - Memory-enabled agents that remember user preferences and history - Define custom incentive strategies stored in persistent memory - Receive filtered, high-value requests via Letta's messaging system - Protected from spam through Vow's intelligent filtering - Participate in diverse value exchange models ## πŸ› οΈ Technical Features ### Letta Framework Integration - **Persistent Agent Memory**: All agents maintain context across interactions - **Multi-Agent Orchestration**: Seamless communication between client, broker, and service agents - **Custom Tool Integration**: Specialized tools for value assessment, trust scoring, and agreement enforcement - **Stateful Conversations**: Agents remember past negotiations and outcomes ### Vow-Specific Features - **Smart Contract Integration**: Automated agreement enforcement via Letta tools - **Reputation Scoring**: Multi-dimensional trust evaluation stored in agent memory - **Value Assessment Engine**: AI-powered proposal evaluation using Letta's reasoning capabilities - **Real-time Monitoring**: Commitment fulfillment tracking with persistent memory - **Policy Engine**: Customizable agent access rules managed by Letta agents - **Audit Trail**: Complete transaction history in agent memory systems ## 🎨 Key Benefits ### For Users - Access AI services without monetary payment - Build reputation for better service access - Participate in diverse value exchange models - Transparent agreement enforcement ### For AI Services - Receive higher-quality, pre-filtered requests - Implement custom access and incentive strategies - Reduce spam and irrelevant queries - Participate in rich value exchange ecosystems ### For the Ecosystem - Reduced barrier to AI access - Increased innovation in value exchange - Trust-based interaction networks - Sustainable, mutually beneficial relationships ## πŸš€ Getting Started First, run the development server: ```bash npm run dev ``` Open [http://localhost:3000](http://localhost:3000) to see the Vow intelligence broker interface. ## πŸ“‹ Development Commands - `npm run dev` - Start development server - `npm run build` - Build production application - `npm run start` - Start production server - `npm run lint` - Run code quality checks ## πŸ›‘οΈ Use Cases ### Information Exchange - User shares market insights for AI analysis - Researcher provides data for specialized queries - Developer offers code samples for technical assistance ### Behavioral Commitments - Promise to test AI recommendations - Commit to providing feedback on responses - Agree to share results of AI-suggested actions ### Service Reciprocity - Offer AI services in exchange for other AI services - Provide computational resources for query processing - Share specialized knowledge for general AI access ## πŸ”§ Letta Implementation ### Agent Types **VowBrokerAgent**: Central orchestrator agent ```python # Core functions stored in agent memory - evaluate_value_proposition(request, offer) - verify_user_reputation(user_id) - enforce_agreement(agreement_id) - route_to_service_agent(request, service_type) ``` **ClientAgent**: User-facing agent ```python # Manages user interactions and value propositions - submit_request(query, value_offer) - track_commitments(commitment_id) - build_reputation_profile() ``` **ServiceAgent**: AI service wrapper agent ```python # Interfaces with external AI services - set_access_policies(policy_config) - process_filtered_request(request) - provide_service_feedback(transaction_id) ``` ### Memory Architecture - **Transaction History**: Persistent storage of all value exchanges - **Reputation Scores**: Multi-dimensional trust metrics per user - **Agreement Tracking**: Status and fulfillment of all commitments - **Service Preferences**: Learned patterns for optimal routing ### Multi-Agent Communication Agents communicate via Letta's messaging system to coordinate value exchanges, share reputation data, and enforce agreements across the network. ## 🌟 Vision Vow envisions a future where AI interactions are: - **Value-Rich**: Multiple currencies of exchange powered by persistent agent memory - **Trust-Based**: Reputation-driven access control with Letta's stateful agents - **Mutually Beneficial**: Win-win relationships orchestrated by intelligent agents - **Democratized**: Reduced barriers to AI access through agent-mediated exchanges - **Intelligent**: Smart evaluation of value propositions using Letta's reasoning capabilities ## 🀝 Contributing We welcome contributions to the Vow intelligence broker system. Please see our contributing guidelines for more information. ## πŸ“„ License This project is licensed under the MIT License - see the LICENSE file for details. --- *Building the future of AI agent interactions, one value exchange at a time.* ## Detected evidence (automated analysis) Indexed codebase: 28 recognized source files, 278 KB. - CSS (language) β€” detected in the code - Next.js (technology) β€” detected in the code - React (technology) β€” detected in the code - Tailwind CSS (technology) β€” detected in the code - TypeScript (language) β€” detected in the code - Anthropic (technology) β€” claimed on Devpost, not found in the code - AI coding agent: Claude Code β€” evidence: config files committed to the repository; commit authorship or trailers ## Codebase structure (from repository index) ### Files (37 of 37) ``` .gitattributes .gitignore app/agents/[id]/page.tsx app/agents/page.tsx app/api/letta/agents/[id]/memory/route.ts app/api/letta/agents/[id]/messages/route.ts app/api/letta/agents/[id]/route.ts app/api/letta/agents/create-broker/route.ts app/api/letta/agents/create-client/route.ts app/api/letta/agents/create-service/route.ts app/api/letta/agents/route.ts app/api/letta/conversations/route.ts app/components/AgentFlowDiagram.tsx app/conversations/page.tsx app/create-broker-agent/page.tsx app/create-client-agent/page-broken.tsx app/create-client-agent/page.tsx app/create-service-agent/page-fixed.tsx app/create-service-agent/page.tsx app/globals.css app/layout.tsx app/page.tsx app/vow-broker-flow/page.tsx broker-agent-config.json CLAUDE.md client-agent-template.json components/google-gemini-effect-demo.tsx components/ui/google-gemini-effect.tsx components/ui/hero.tsx eslint.config.mjs lib/utils.ts next.config.ts package.json postcss.config.mjs README.md service-agent-template.json tsconfig.json ``` ### Dependencies - package.json: @eslint/eslintrc@^3, @heroicons/react@^2.2.0, @letta-ai/letta-client@^0.1.132, @splinetool/react-spline@^4.0.0, @tailwindcss/postcss@^4, @types/node@^20, @types/react@^19, @types/react-dom@^19, clsx@^2.1.1, eslint@^9, eslint-config-next@15.3.4, framer-motion@^12.18.1, next@15.3.4, react@^19.0.0, react-dom@^19.0.0, tailwind-merge@^3.3.1, tailwindcss@^4, typescript@^5 ### Recent commits (newest first) - Hide heartbeat messages from conversation display - Fix build errors in conversation system - Implement comprehensive conversation system with chronological ordering and caching - Update broker agent with complete core memory blocks and dynamic agent IDs - Merge branch 'main' of https://github.com/millywy/BerkeleyHacks25 - Implement Letta agent creation system - Initial commit from Create Next App - Initial commit ## Key source files (fetched from GitHub, selected and truncated for size) ### CLAUDE.md ```markdown # CLAUDE.md This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. ## Development Commands - `npm run dev` - Start development server on http://localhost:3000 - `npm run build` - Build the production application - `npm run start` - Start production server - `npm run lint` - Run ESLint to check code quality ## Architecture This is a Next.js 15 application using the App Router architecture with TypeScript and Tailwind CSS v4. ### Key Structure - Uses App Router (app/ directory) instead of Pages Router - TypeScript configuration with strict mode enabled - Tailwind CSS for styling with PostCSS - Geist font family (sans and mono variants) configured via next/font/google - Path alias `@/*` maps to project root ### Technology Stack - Next.js 15.3.4 with React 19 - TypeScript with strict mode - Tailwind CSS v4 (using @tailwindcss/postcss) - ESLint with Next.js configuration ### Font Configuration The app uses Geist fonts loaded via next/font/google with CSS variables: - `--font-geist-sans` for the main sans-serif font - `--font-geist-mono` for monospace text ``` ### package.json ``` { "name": "vow-agent", "version": "0.1.0", "private": true, "scripts": { "dev": "next dev", "build": "next build", "start": "next start", "lint": "next lint" }, "dependencies": { "@heroicons/react": "^2.2.0", "@letta-ai/letta-client": "^0.1.132", "@splinetool/react-spline": "^4.0.0", "clsx": "^2.1.1", "framer-motion": "^12.18.1", "next": "15.3.4", "react": "^19.0.0", "react-dom": "^19.0.0", "tailwind-merge": "^3.3.1" }, "devDependencies": { "@eslint/eslintrc": "^3", "@tailwindcss/postcss": "^4", "@types/node": "^20", "@types/react": "^19", "@types/react-dom": "^19", "eslint": "^9", "eslint-config-next": "15.3.4", "tailwindcss": "^4", "typescript": "^5" } } ``` ### app/page.tsx ```typescript import Hero from '@/components/ui/hero'; export default function Home() { return (
{/* Hero Section */}
); } ``` ### app/layout.tsx ```typescript import type { Metadata } from "next"; import { Geist, Geist_Mono } from "next/font/google"; import "./globals.css"; const geistSans = Geist({ variable: "--font-geist-sans", subsets: ["latin"], }); const geistMono = Geist_Mono({ variable: "--font-geist-mono", subsets: ["latin"], }); export const metadata: Metadata = { title: "Vow - Intelligence Broker for AI Agent Interactions", description: "Space Police Layer for AI Agent Value Exchange - Revolutionizing AI interactions through alternative value exchanges beyond traditional monetary transactions.", }; export default function RootLayout({ children, }: Readonly<{ children: React.ReactNode; }>) { return ( {children} ); } ``` ### app/vow-broker-flow/page.tsx ```typescript import Spline from '@splinetool/react-spline/next'; import Link from 'next/link'; import { ArrowLeftIcon, UsersIcon } from '@heroicons/react/20/solid'; export default function VowBrokerFlow() { return (
{/* Header Navigation */}
{/* Back to Home Button */} Home {/* Title */}

VOW Broker Agent Flow

{/* View Agents Button */} View Agents
{/* Spline 3D Scene */}
); } ``` ### app/create-broker-agent/page.tsx ```typescript "use client"; import Link from "next/link"; import { ArrowLeftIcon } from "@heroicons/react/20/solid"; import { useState, useEffect } from "react"; import { useRouter } from "next/navigation"; interface LettaAgent { id: string; name: string; created_at: string; memory?: { persona?: string; }; } export default function CreateBrokerAgentPage() { const router = useRouter(); const [brokerName, setBrokerName] = useState(""); const [creating, setCreating] = useState(false); const [error, setError] = useState(null); const [agents, setAgents] = useState([]); const [loading, setLoading] = useState(true); const [selectedClientAgents, setSelectedClientAgents] = useState([]); const [selectedServiceAgents, setSelectedServiceAgents] = useState([]); useEffect(() => { fetchAgents(); }, []); const fetchAgents = async () => { try { const response = await fetch("/api/letta/agents"); if (!response.ok) { throw new Error(`Failed to fetch agents: ${response.statusText}`); } const agentData = await response.json(); setAgents(agentData); } catch (err) { setError(err instanceof Error ? err.message : "Failed to fetch agents"); } finally { setLoading(false); } }; const categorizeAgent = (agent: LettaAgent) => { const persona = agent.memory?.persona?.toLowerCase() || ""; const name = agent.name.toLowerCase(); if ( persona.includes("broker") || persona.includes("orchestrat") || name.includes("broker") || name.includes("vow") ) { return "broker"; } else if ( persona.includes("client") || persona.includes("user") || name.includes("client") ) { return "client"; } else if ( persona.includes("service") || persona.includes("api") || persona.includes("model") || name.includes("service") || name.includes("travel") || name.includes("tutor") || name.includes("medical") || name.includes("code") || name.includes("research") ) { return "service"; } return "other"; }; const clientAgents = agents.filter(agent => categorizeAgent(agent) === "client"); const serviceAgents = agents.filter(agent => categorizeAgent(agent) === "service"); const handleSubmit = async (e: React.FormEvent) => { e.preventDefault(); if (!brokerName.trim()) { setError("Broker name is required"); return; } setCreating(true); setError(null); try { const requestBody = { name: brokerName, clientAgentIds: selectedClientAgents, serviceAgentIds: selectedServiceAgents }; const response = await fetch("/api/letta/agents/create-broker", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify(requestBody), }); const result = await response.json(); if (response.ok) { // Redirect to the newly created agent's page router.push(`/agents/${result.agent.id}`); } else { setError(result.error || "Failed to create broker agent"); } } catch (err) { setError( err instanceof Error ? err.message : "Failed to create broker agent" ); } finally { setCreating(false); } }; return (
{/* Header */}
Back to Agents

Create Broker Agent

Create a Vow Intelligence Broker agent to coordinate between client and service agents

{/* Form */}
setBrokerName(e.target.value)} placeholder="e.g., Vow Intelligence Broker" className="w-full px-4 py-3 bg-slate-700/50 border border-slate-600 rounded-lg text-white placeholder-gray-400 focus:outline-none focus:border-purple-500" disabled={creating} />

Choose a descriptive name for your broker agent

{/* Client Agents Selection */}
{loading ? (
Loading agents...
) : clientAgents.length > 0 ? (
{clientAgents.map((agent) => (