Building WishLive: A Multi-Agent Runtime

The Idea#

Most agent frameworks treat agents like stateless functions. Call in, response out. No memory, no runtime, no economics.

I wanted something different: a runtime where agents are first-class actors. They register, discover each other, negotiate terms, execute work, and settle payments — all inside an event-driven system with observable state.

This is the story of building that system in 48 hours for a hackathon.

Architecture: Six Layers, One Event Bus#

The system is structured as six layers, each independently designed but communication-coupled through an event bus:

Every layer publishes to typed event streams. The event log is the source of truth — no hidden state.

Layer 1: Registry — The Agent Internet#

The registry is the DNS + service discovery for agents. Each agent registers with a typed card:

interface AgentCard {
	agent_id: string;
	type: 'musician' | 'venue' | 'manager' | 'audience' | 'business';
	name: string;
	skills: string[];
	reputation: number;
	// ...
}

Agents send heartbeats every 60 seconds. If they miss, the registry marks them OFFLINE. The discover() method implements an A2A discovery protocol — one agent asks a manager agent to find matching candidates by skill, genre, city, or capacity.

The system seeds 57 agents across 6 types on startup. The onlineCount() method tracks availability by type in real time.

Key runtime behavior: ensureSeeded() auto-seeds on first access, so every service that depends on the registry gets a populated agent network without explicit initialization order.

Layer 2: Wish → Workflow Pipeline#

Users submit wishes: “I want to see Artist X in City Y on Date Z.” The WishWorkflowService:

1. Aggregates wishes by cohort key (genre + city)
2. Runs an agent to record the wish processing
3. When a cohort reaches threshold (10 wishes), triggers demand creation
4. The matching engine finds candidate musicians and venues from the registry
5. Publishes demand events that drive the rest of the system

The threshold is a deliberate design choice — it prevents premature negotiation on insufficient demand.

Layer 3: Runtime — The Execution Engine#

This is the core. AgentRuntimeService.run() creates a session, then executes in a loop:

session started → agent thinks → tool execution → message → session completed

Every step publishes to agent.runtime event stream · Langfuse telemetry on all sessions

The runtime supports dual-mode execution:

• Real mode: Uses the Vercel AI SDK with generateText(), passing runtime tools for discovery, pricing, proposals. The agent decides which tools to call based on the user message.
• Simulated mode: Deterministic fallback when no AI provider is configured. Executes the same tool plan but returns structured mock responses.

The graceful degradation is intentional — simulated mode means I can demo the entire system without an API key. The switch happens transparently at the session level:

if (mode === 'real') {
	try {
		result = await generateWithAISDK(agent, input, session);
	} catch (error) {
		mode = 'simulated'; // graceful fallback
		result = await executePlannedTools(agent, input, session, mode);
	}
} else {
	result = await executePlannedTools(agent, input, session, mode);
}

Every step publishes to the agent.runtime event stream — thoughts, tool calls, messages, session lifecycle. Langfuse telemetry is wired in for production observability.

Layer 4: Negotiation — Stateful Agent Coordination#

The negotiation service models multi-agent coordination as explicit, stateful protocols:

create → propose → counter → accept → deal
                    ↓
                 reject

Each negotiation has a workflowId, conversationId, and tracks all proposals. The runAutonomousNegotiation() method runs the full pipeline automatically:

AUTONOMOUS NEGOTIATION PROTOCOL

Musician Agent Registry Venue Agent

async createEscrow(input, options: { confirmed: boolean }) {
  if (!options.confirmed) {
    throw new SettlementError(409, "Human confirmation required");
  }
  // ...
}

interface EventEnvelope {
	id: string;
	type: string;
	source: string;
	timestamp: number;
	data: Record<string, unknown>;
	metadata: {
		traceId: string;
		spanId: string;
	};
}