diff --git a/src/ax/arena/README.md b/src/ax/arena/README.md
new file mode 100644
index 00000000..eaa84679
--- /dev/null
+++ b/src/ax/arena/README.md
@@ -0,0 +1,316 @@
+# AxArena - Multi-Agent Coordination System
+
+AxArena is a sophisticated messaging and coordination system for orchestrating multiple AxAgent instances with intelligent planning and task management capabilities.
+
+## Architecture Overview
+
+AxArena uses a three-stage process for handling user requests:
+
+1. **Context Consolidation**: Analyzes conversation history and creates a clear, actionable task
+2. **Planning**: Breaks down complex tasks into step-by-step execution plans
+3. **Task Management**: Executes individual tasks by routing them to the most appropriate agents
+
+### Core Components
+
+#### 1. Context Consolidator Agent
+- Analyzes conversation threads and user messages
+- Consolidates multiple messages into clear, actionable tasks
+- Considers conversation history and original thread context
+- Outputs structured tasks suitable for planning
+
+#### 2. Planning Agent
+- Takes consolidated tasks and creates detailed execution plans
+- Breaks down complex tasks into manageable steps
+- Assigns each step to appropriate agents based on expertise
+- Manages task dependencies and execution order
+- Creates structured plans with step IDs and clear success criteria
+
+#### 3. Task Manager Agent
+- Routes individual tasks to the best available agents
+- Considers agent specializations and current workload
+- Manages task execution state and progress tracking
+- Handles task completion and failure scenarios
+
+#### 4. Execution Plans
+Each plan contains:
+- **Plan ID**: Unique identifier for tracking
+- **Tasks**: Individual steps with descriptions, assignments, and dependencies
+- **Status Tracking**: Real-time progress monitoring
+- **Agent Assignment**: Intelligent routing based on expertise matching
+
+## Features
+
+- **Intelligent Agent Routing**: Automatically selects the best agent for each task
+- **Step-by-Step Execution**: Breaks complex requests into manageable tasks
+- **Real-time Progress Tracking**: Monitor execution status and agent participation
+- **Dependency Management**: Handles task dependencies and sequential execution
+- **Event-Driven Architecture**: Real-time updates and notifications
+- **Thread Management**: Multiple concurrent conversations with isolated contexts
+- **Execution Plan Persistence**: Track and review completed workflows
+
+## Basic Usage
+
+```typescript
+import { AxArena, AxAgent } from '@ax-llm/ax'
+
+// Create specialized agents
+const architect = new AxAgent({
+  name: 'System Architect',
+  description: 'Expert in system design and architecture patterns',
+  signature: `requirements -> architecture:string, components:string[]`,
+})
+
+const developer = new AxAgent({
+  name: 'Senior Developer', 
+  description: 'Expert in implementation and coding best practices',
+  signature: `architecture, specs -> implementation:string, tests:string`,
+})
+
+const tester = new AxAgent({
+  name: 'QA Engineer',
+  description: 'Expert in testing strategies and quality assurance',
+  signature: `implementation -> testPlan:string, coverage:string`,
+})
+
+// Create arena with planning and task management
+const arena = new AxArena({
+  maxMessagesPerThread: 1000,
+  maxConcurrentThreads: 10,
+  debug: true,
+})
+
+// Create a development thread
+const thread = arena.createThread(
+  [architect, developer, tester],
+  'Build a high-performance web application'
+)
+
+// Send a complex request - planning agent will break it down
+const response = await arena.sendMessage(
+  thread.id,
+  `Create a scalable microservices architecture with:
+  1. User authentication and authorization
+  2. Real-time data processing pipeline  
+  3. Comprehensive testing strategy
+  4. Performance monitoring and observability`,
+  'product_manager'
+)
+
+// Check execution plan
+const plan = arena.getExecutionPlan(thread.id)
+console.log(`Plan created with ${plan?.tasks.length} tasks`)
+console.log(`Status: ${plan?.status}`)
+
+// Review task breakdown
+plan?.tasks.forEach((task, index) => {
+  console.log(`${index + 1}. ${task.description}`)
+  console.log(`   Agent: ${task.assignedAgentName}`)
+  console.log(`   Status: ${task.status}`)
+})
+```
+
+## Advanced Configuration
+
+### Arena Configuration
+
+```typescript
+const arena = new AxArena({
+  maxMessagesPerThread: 500,    // Maximum messages per conversation
+  maxConcurrentThreads: 5,      // Maximum concurrent threads
+  debug: true,                  // Enable detailed logging
+})
+```
+
+### Specialized Agent Teams
+
+```typescript
+// CUDA Development Team
+const cudaTeam = [
+  new AxAgent({
+    name: 'CUDA Architect',
+    description: 'Expert in CUDA architecture and GPU programming patterns',
+    signature: `requirements -> architecture:string, memoryStrategy:string`,
+  }),
+  new AxAgent({
+    name: 'CUDA Developer', 
+    description: 'Specialized in CUDA kernel implementation',
+    signature: `architecture -> kernelCode:string, launchConfig:string`,
+  }),
+  new AxAgent({
+    name: 'Performance Optimizer',
+    description: 'Expert in CUDA performance optimization',
+    signature: `kernelCode -> optimizations:string, benchmarks:string`,
+  }),
+]
+
+// AI/ML Research Team  
+const mlTeam = [
+  new AxAgent({
+    name: 'ML Researcher',
+    description: 'Expert in machine learning algorithms and research',
+    signature: `problem -> approach:string, methodology:string`,
+  }),
+  new AxAgent({
+    name: 'Data Scientist',
+    description: 'Expert in data analysis and feature engineering', 
+    signature: `dataset -> features:string[], preprocessing:string`,
+  }),
+  new AxAgent({
+    name: 'ML Engineer',
+    description: 'Expert in ML model deployment and productionization',
+    signature: `model -> deployment:string, monitoring:string`,
+  }),
+]
+```
+
+## Event Handling
+
+AxArena emits events for real-time monitoring:
+
+```typescript
+// Listen to all arena events
+arena.on('event', (event) => {
+  console.log(`Event: ${event.type} in thread ${event.threadId}`)
+})
+
+// Listen to specific events
+arena.on('message', (event) => {
+  console.log(`New message: ${event.data.content}`)
+})
+
+arena.on('response', (event) => {
+  console.log(`Agent response: ${event.data.sender}`)
+})
+
+arena.on('threadCreated', (event) => {
+  console.log(`New thread created: ${event.threadId}`)
+})
+
+arena.on('thread_updated', (event) => {
+  console.log(`Thread updated: ${event.threadId}`)
+})
+```
+
+## Execution Plan Management
+
+### Monitoring Plan Progress
+
+```typescript
+// Get current execution plan
+const plan = arena.getExecutionPlan(threadId)
+
+if (plan) {
+  console.log(`Plan Status: ${plan.status}`)
+  console.log(`Progress: ${plan.tasks.filter(t => t.status === 'completed').length}/${plan.tasks.length}`)
+  
+  // Check individual task status
+  plan.tasks.forEach(task => {
+    console.log(`Task ${task.id}: ${task.status}`)
+    if (task.result) {
+      console.log(`Result: ${task.result}`)
+    }
+  })
+}
+```
+
+### Task Lifecycle
+
+Each task goes through these states:
+- `pending`: Task created but not started
+- `in-progress`: Task assigned and being executed  
+- `completed`: Task finished successfully
+- `failed`: Task encountered an error
+
+### Plan Status
+
+Execution plans have these states:
+- `pending`: Plan created but execution not started
+- `in-progress`: Tasks are being executed
+- `completed`: All tasks completed successfully
+- `failed`: Plan failed due to critical task failure
+
+## Thread Management
+
+```typescript
+// Create thread with metadata
+const thread = arena.createThread(
+  agents,
+  'Complex development project',
+  {
+    metadata: {
+      project: 'webapp-v2',
+      priority: 'high',
+      deadline: '2024-03-01',
+    }
+  }
+)
+
+// Thread lifecycle management
+arena.pauseThread(thread.id)   // Pause execution
+arena.resumeThread(thread.id)  // Resume execution  
+arena.completeThread(thread.id) // Mark as completed
+arena.deleteThread(thread.id)  // Delete thread and execution plan
+
+// Get thread information
+const allThreads = arena.getAllThreads()
+const specificThread = arena.getThread(thread.id)
+```
+
+## Real-World Example: CUDA Kernel Development
+
+```typescript
+import { demonstrateCudaArena } from '@ax-llm/ax-examples'
+
+// Run comprehensive CUDA kernel development workflow
+await demonstrateCudaArena()
+```
+
+This example demonstrates:
+- Planning agent breaking down complex CUDA development into steps
+- Task manager routing each step to specialized agents
+- Real-time progress tracking and agent coordination
+- Complete workflow from architecture to documentation
+
+## API Reference
+
+### AxArena Methods
+
+- `createThread(agents, task, options?)`: Create new conversation thread
+- `sendMessage(threadId, content, sender?, options?)`: Send message with planning and execution
+- `getThread(threadId)`: Get thread by ID
+- `getExecutionPlan(threadId)`: Get execution plan for thread
+- `getAllThreads()`: Get all threads
+- `getAllExecutionPlans()`: Get all execution plans
+- `pauseThread(threadId)`: Pause thread execution
+- `resumeThread(threadId)`: Resume thread execution
+- `completeThread(threadId)`: Mark thread as completed
+- `deleteThread(threadId)`: Delete thread and its execution plan
+
+### Event Types
+
+- `threadCreated`: New thread created
+- `message`: New message received
+- `response`: Agent response generated
+- `thread_updated`: Thread state changed
+- `event`: All events (catch-all)
+
+## Integration with AI Services
+
+When AI services are configured, AxArena will use:
+
+1. **Context Consolidator Agent**: Advanced conversation analysis and task consolidation
+2. **Planning Agent**: Intelligent task breakdown and dependency management  
+3. **Task Manager Agent**: Smart agent selection based on expertise matching
+
+Without AI services, AxArena falls back to rule-based routing and simple task execution while maintaining the same API and workflow structure.
+
+## Best Practices
+
+1. **Agent Specialization**: Create agents with clear, distinct specializations
+2. **Task Granularity**: Design tasks that can be completed by individual agents
+3. **Dependency Management**: Structure workflows with clear dependencies
+4. **Progress Monitoring**: Use events and execution plans to track progress
+5. **Error Handling**: Monitor task failures and implement recovery strategies
+6. **Thread Organization**: Use metadata to organize and categorize threads
+
+AxArena provides a powerful foundation for building sophisticated multi-agent workflows with intelligent planning and coordination capabilities. 
\ No newline at end of file
diff --git a/src/ax/arena/arena.ts b/src/ax/arena/arena.ts
new file mode 100644
index 00000000..a85aec15
--- /dev/null
+++ b/src/ax/arena/arena.ts
@@ -0,0 +1,502 @@
+import { randomUUID } from 'crypto'
+import { EventEmitter } from 'events'
+
+import type { AxAgentic } from '../prompts/agent.js'
+
+import {
+  completeTask,
+  createArenaContextConsolidator,
+  createArenaPlanningAgent,
+  createArenaTaskManager,
+  createExecutionPlan,
+  executeNextTask,
+  failTask,
+} from './router.js'
+import type {
+  AxArenaConfig,
+  AxArenaEvent,
+  AxArenaExecutionPlan,
+  AxArenaMessage,
+  AxArenaMessageAttachment,
+  AxArenaResponse,
+  AxArenaSendMessageOptions,
+  AxArenaThread,
+} from './types.js'
+
+/**
+ * AxArena - A messaging system for coordinating multiple AxAgent instances
+ * with planning and task management capabilities
+ */
+export class AxArena extends EventEmitter {
+  private threads: Map<string, AxArenaThread> = new Map()
+  private executionPlans: Map<string, AxArenaExecutionPlan> = new Map()
+  private config: Required<AxArenaConfig>
+  private contextConsolidator = createArenaContextConsolidator()
+  private planningAgent = createArenaPlanningAgent(() =>
+    this.getAgentInfoForThread()
+  )
+  private taskManager = createArenaTaskManager(() =>
+    this.getAgentInfoForThread()
+  )
+
+  private currentThreadId: string | null = null
+
+  constructor(config?: AxArenaConfig) {
+    super()
+
+    this.config = {
+      maxMessagesPerThread: config?.maxMessagesPerThread ?? 1000,
+      maxConcurrentThreads: config?.maxConcurrentThreads ?? 10,
+      debug: config?.debug ?? false,
+    }
+  }
+
+  /**
+   * Creates a new thread with the given agents and task
+   */
+  public createThread(
+    agents: AxAgentic[],
+    task: string,
+    options?: {
+      threadId?: string
+      metadata?: Record<string, unknown>
+    }
+  ): AxArenaThread {
+    if (this.threads.size >= this.config.maxConcurrentThreads) {
+      throw new Error(
+        `Maximum number of concurrent threads (${this.config.maxConcurrentThreads}) reached`
+      )
+    }
+
+    const threadId = options?.threadId ?? randomUUID()
+    const now = new Date()
+
+    const thread: AxArenaThread = {
+      id: threadId,
+      task,
+      agents,
+      messages: [],
+      status: 'active',
+      createdAt: now,
+      updatedAt: now,
+      metadata: options?.metadata ?? {},
+    }
+
+    this.threads.set(threadId, thread)
+
+    // Add initial system message with the task
+    const initialMessage: AxArenaMessage = {
+      id: randomUUID(),
+      threadId,
+      sender: 'system',
+      content: task,
+      timestamp: now,
+    }
+
+    thread.messages.push(initialMessage)
+
+    this.emitEvent({
+      type: 'threadCreated',
+      threadId,
+      data: thread,
+      timestamp: now,
+    })
+
+    if (this.config.debug) {
+      console.log(
+        `[AxArena] Created thread ${threadId} with ${agents.length} agents`
+      )
+    }
+
+    return thread
+  }
+
+  /**
+   * Sends a message to a thread and processes it through the planning and task management system
+   */
+  public async sendMessage(
+    threadId: string,
+    content: string,
+    sender: string = 'user',
+    options?: AxArenaSendMessageOptions
+  ): Promise<AxArenaResponse> {
+    const thread = this.threads.get(threadId)
+    if (!thread) {
+      throw new Error(`Thread ${threadId} not found`)
+    }
+
+    if (thread.status !== 'active') {
+      throw new Error(
+        `Thread ${threadId} is not active (status: ${thread.status})`
+      )
+    }
+
+    if (thread.messages.length >= this.config.maxMessagesPerThread) {
+      throw new Error(
+        `Thread ${threadId} has reached maximum message limit (${this.config.maxMessagesPerThread})`
+      )
+    }
+
+    const startTime = Date.now()
+    const now = new Date()
+
+    // Create the message
+    const message: AxArenaMessage = {
+      id: randomUUID(),
+      threadId,
+      sender,
+      content,
+      timestamp: now,
+      attachments: options?.metadata?.attachments as
+        | AxArenaMessageAttachment[]
+        | undefined,
+      labels: options?.metadata?.labels as string[],
+      replyTo: options?.metadata?.replyTo as string,
+    }
+
+    // Add message to thread
+    thread.messages.push(message)
+    thread.updatedAt = now
+
+    this.emitEvent({
+      type: 'message',
+      threadId,
+      data: message,
+      timestamp: now,
+    })
+
+    if (this.config.debug) {
+      console.log(
+        `[AxArena] Message sent to thread ${threadId}: ${content.substring(0, 100)}...`
+      )
+    }
+
+    // Set current thread for agent info lookup
+    this.currentThreadId = threadId
+
+    try {
+      const responses: AxArenaMessage[] = []
+      const selectedAgents: string[] = []
+
+      // Step 1: Context consolidation
+      const consolidatedTask = this.consolidateContext(
+        thread.messages,
+        thread.task
+      )
+
+      if (this.config.debug) {
+        console.log(`[AxArena] Consolidated task: ${consolidatedTask}`)
+      }
+
+      // Step 2: Create or get execution plan
+      let plan = this.executionPlans.get(threadId)
+      if (!plan) {
+        plan = await createExecutionPlan(
+          this.planningAgent,
+          consolidatedTask,
+          thread.task,
+          thread.agents
+        )
+        this.executionPlans.set(threadId, plan)
+
+        if (this.config.debug) {
+          console.log(
+            `[AxArena] Created execution plan with ${plan.tasks.length} tasks`
+          )
+          console.log(`[AxArena] Plan tasks:`)
+          plan.tasks.forEach((task, index) => {
+            console.log(
+              `   ${index + 1}. ${task.description} -> ${task.assignedAgentName}`
+            )
+          })
+        }
+      }
+
+      // Step 3: Execute tasks sequentially until completion or no more tasks available
+      let taskExecuted = false
+      let maxIterations = plan.tasks.length + 1 // Prevent infinite loops
+      let iterations = 0
+
+      while (iterations < maxIterations) {
+        const { task, selectedAgent } = await executeNextTask(
+          this.taskManager,
+          plan,
+          thread.agents
+        )
+
+        if (!task || !selectedAgent) {
+          // No more tasks to execute
+          break
+        }
+
+        taskExecuted = true
+        selectedAgents.push(selectedAgent.getFunction().name)
+
+        if (this.config.debug) {
+          console.log(
+            `[AxArena] Executing task: ${task.id} - ${task.description}`
+          )
+          console.log(
+            `[AxArena] Assigned to: ${selectedAgent.getFunction().name}`
+          )
+        }
+
+        // Execute the selected agent with the task description
+        try {
+          // For now, create a structured response based on the task
+          // TODO: Integrate with actual agent execution when method is available
+          const taskResult = `Task completed by ${selectedAgent.getFunction().name}: ${task.description}`
+
+          const responseMessage: AxArenaMessage = {
+            id: randomUUID(),
+            threadId,
+            sender: selectedAgent.getFunction().name,
+            content: taskResult,
+            timestamp: new Date(),
+          }
+
+          thread.messages.push(responseMessage)
+          responses.push(responseMessage)
+
+          // Mark task as completed
+          completeTask(plan, task.id, taskResult)
+
+          this.emitEvent({
+            type: 'response',
+            threadId,
+            data: responseMessage,
+            timestamp: responseMessage.timestamp,
+          })
+
+          if (this.config.debug) {
+            console.log(
+              `[AxArena] Task ${task.id} completed by ${selectedAgent.getFunction().name}`
+            )
+          }
+        } catch (error) {
+          // Handle agent execution error
+          const errorMessage = `Agent execution failed: ${error}`
+          const fallbackResult = `[Error] Unable to execute task: ${task.description}`
+
+          const errorResponse: AxArenaMessage = {
+            id: randomUUID(),
+            threadId,
+            sender: selectedAgent.getFunction().name,
+            content: fallbackResult,
+            timestamp: new Date(),
+          }
+
+          thread.messages.push(errorResponse)
+          responses.push(errorResponse)
+
+          // Mark task as failed
+          failTask(plan, task.id, errorMessage)
+
+          this.emitEvent({
+            type: 'response',
+            threadId,
+            data: errorResponse,
+            timestamp: errorResponse.timestamp,
+          })
+
+          if (this.config.debug) {
+            console.log(`[AxArena] Task ${task.id} failed: ${errorMessage}`)
+          }
+        }
+
+        iterations++
+      }
+
+      // Check if plan is complete
+      if (plan.status === 'completed') {
+        if (this.config.debug) {
+          console.log(
+            `[AxArena] Execution plan completed for thread ${threadId}`
+          )
+        }
+
+        // Create plan completion summary
+        const summaryMessage: AxArenaMessage = {
+          id: randomUUID(),
+          threadId,
+          sender: 'system',
+          content: `Execution plan completed successfully. All ${plan.tasks.length} tasks have been executed.`,
+          timestamp: new Date(),
+        }
+
+        thread.messages.push(summaryMessage)
+        responses.push(summaryMessage)
+
+        this.emitEvent({
+          type: 'response',
+          threadId,
+          data: summaryMessage,
+          timestamp: summaryMessage.timestamp,
+        })
+      }
+
+      if (!taskExecuted) {
+        // No tasks were executed, provide fallback response
+        const fallbackResponse: AxArenaMessage = {
+          id: randomUUID(),
+          threadId,
+          sender: 'system',
+          content: 'No actionable tasks found for the current request.',
+          timestamp: new Date(),
+        }
+
+        thread.messages.push(fallbackResponse)
+        responses.push(fallbackResponse)
+
+        this.emitEvent({
+          type: 'response',
+          threadId,
+          data: fallbackResponse,
+          timestamp: fallbackResponse.timestamp,
+        })
+      }
+
+      thread.updatedAt = new Date()
+
+      this.emitEvent({
+        type: 'thread_updated',
+        threadId,
+        data: thread,
+        timestamp: new Date(),
+      })
+
+      const processingTime = Date.now() - startTime
+
+      return {
+        originalMessage: message,
+        responses,
+        selectedAgents,
+        processingTime,
+      }
+    } finally {
+      this.currentThreadId = null
+    }
+  }
+
+  /**
+   * Gets the current execution plan for a thread
+   */
+  public getExecutionPlan(threadId: string): AxArenaExecutionPlan | undefined {
+    return this.executionPlans.get(threadId)
+  }
+
+  /**
+   * Gets all execution plans
+   */
+  public getAllExecutionPlans(): AxArenaExecutionPlan[] {
+    return Array.from(this.executionPlans.values())
+  }
+
+  /**
+   * Gets a thread by ID
+   */
+  public getThread(threadId: string): AxArenaThread | undefined {
+    return this.threads.get(threadId)
+  }
+
+  /**
+   * Gets all threads
+   */
+  public getAllThreads(): AxArenaThread[] {
+    return Array.from(this.threads.values())
+  }
+
+  /**
+   * Pauses a thread
+   */
+  public pauseThread(threadId: string): void {
+    const thread = this.threads.get(threadId)
+    if (thread) {
+      thread.status = 'paused'
+      thread.updatedAt = new Date()
+    }
+  }
+
+  /**
+   * Resumes a thread
+   */
+  public resumeThread(threadId: string): void {
+    const thread = this.threads.get(threadId)
+    if (thread) {
+      thread.status = 'active'
+      thread.updatedAt = new Date()
+    }
+  }
+
+  /**
+   * Completes a thread
+   */
+  public completeThread(threadId: string): void {
+    const thread = this.threads.get(threadId)
+    if (thread) {
+      thread.status = 'completed'
+      thread.updatedAt = new Date()
+    }
+  }
+
+  /**
+   * Deletes a thread and its execution plan
+   */
+  public deleteThread(threadId: string): boolean {
+    this.executionPlans.delete(threadId)
+    return this.threads.delete(threadId)
+  }
+
+  /**
+   * Simple context consolidation (placeholder for actual AI-powered consolidation)
+   */
+  private consolidateContext(
+    messages: readonly AxArenaMessage[],
+    threadTask: string
+  ): string {
+    // For now, use simple consolidation until AI service is configured
+    // TODO: Implement actual consolidator call when AI service is available
+
+    const latestMessage = messages[messages.length - 1]
+    if (latestMessage && latestMessage.sender !== 'system') {
+      return latestMessage.content
+    }
+
+    return threadTask
+  }
+
+  /**
+   * Gets agent information for the current thread (used by planning and task management agents)
+   */
+  private getAgentInfoForThread(): Array<{
+    id: string
+    name: string
+    description: string
+  }> {
+    if (!this.currentThreadId) {
+      return []
+    }
+
+    const thread = this.threads.get(this.currentThreadId)
+    if (!thread) {
+      return []
+    }
+
+    return thread.agents.map((agent, index) => {
+      const func = agent.getFunction()
+      return {
+        id: index.toString(), // Use index as ID for now
+        name: func.name,
+        description: func.description,
+      }
+    })
+  }
+
+  /**
+   * Emits an event
+   */
+  private emitEvent(event: Readonly<AxArenaEvent>): void {
+    this.emit(event.type, event)
+    this.emit('event', event)
+  }
+}
diff --git a/src/ax/arena/control.ts b/src/ax/arena/control.ts
new file mode 100644
index 00000000..afa5d396
--- /dev/null
+++ b/src/ax/arena/control.ts
@@ -0,0 +1,281 @@
+import type { AxFunction } from '../ai/types.js'
+
+import type { AxArena } from './arena.js'
+
+/**
+ * Creates an AxFunction for getting a specific thread by ID
+ */
+export function getThreadFunction(
+  arena: Readonly<AxArena>,
+  threadId: string
+): AxFunction {
+  return {
+    name: 'getThread',
+    description: `Get the arena thread with ID ${threadId}`,
+    parameters: {
+      type: 'object',
+      properties: {},
+      required: [],
+    },
+    func: async () => {
+      const thread = arena.getThread(threadId)
+      if (!thread) {
+        return `Thread with ID ${threadId} not found`
+      }
+      return JSON.stringify(thread, null, 2)
+    },
+  }
+}
+
+/**
+ * Creates an AxFunction for getting all threads in the arena
+ */
+export function getAllThreadsFunction(arena: Readonly<AxArena>): AxFunction {
+  return {
+    name: 'getAllThreads',
+    description: 'Get all threads in the arena',
+    parameters: {
+      type: 'object',
+      properties: {},
+      required: [],
+    },
+    func: async () => {
+      const threads = arena.getAllThreads()
+      return JSON.stringify(threads, null, 2)
+    },
+  }
+}
+
+/**
+ * Creates an AxFunction for getting agents from a specific thread
+ */
+export function getAgentsFunction(
+  arena: Readonly<AxArena>,
+  threadId: string
+): AxFunction {
+  return {
+    name: 'getAgents',
+    description: `Get all agents participating in thread ${threadId}`,
+    parameters: {
+      type: 'object',
+      properties: {},
+      required: [],
+    },
+    func: async () => {
+      const thread = arena.getThread(threadId)
+      if (!thread) {
+        return `Thread with ID ${threadId} not found`
+      }
+      const agents = thread.agents.map((agent) => ({
+        name: agent.getFunction().name,
+        description: agent.getFunction().description,
+        features: agent.getFeatures(),
+      }))
+      return JSON.stringify(agents, null, 2)
+    },
+  }
+}
+
+/**
+ * Creates an AxFunction for pausing a thread
+ */
+export function pauseThreadFunction(
+  arena: Readonly<AxArena>,
+  threadId: string
+): AxFunction {
+  return {
+    name: 'pauseThread',
+    description: `Pause thread ${threadId} to stop processing new messages`,
+    parameters: {
+      type: 'object',
+      properties: {},
+      required: [],
+    },
+    func: async () => {
+      const thread = arena.getThread(threadId)
+      if (!thread) {
+        return `Thread with ID ${threadId} not found`
+      }
+      arena.pauseThread(threadId)
+      return `Thread ${threadId} has been paused`
+    },
+  }
+}
+
+/**
+ * Creates an AxFunction for resuming a thread
+ */
+export function resumeThreadFunction(
+  arena: Readonly<AxArena>,
+  threadId: string
+): AxFunction {
+  return {
+    name: 'resumeThread',
+    description: `Resume thread ${threadId} to continue processing messages`,
+    parameters: {
+      type: 'object',
+      properties: {},
+      required: [],
+    },
+    func: async () => {
+      const thread = arena.getThread(threadId)
+      if (!thread) {
+        return `Thread with ID ${threadId} not found`
+      }
+      arena.resumeThread(threadId)
+      return `Thread ${threadId} has been resumed`
+    },
+  }
+}
+
+/**
+ * Creates an AxFunction for completing a thread
+ */
+export function completeThreadFunction(
+  arena: Readonly<AxArena>,
+  threadId: string
+): AxFunction {
+  return {
+    name: 'completeThread',
+    description: `Mark thread ${threadId} as completed, stopping all further processing`,
+    parameters: {
+      type: 'object',
+      properties: {},
+      required: [],
+    },
+    func: async () => {
+      const thread = arena.getThread(threadId)
+      if (!thread) {
+        return `Thread with ID ${threadId} not found`
+      }
+      arena.completeThread(threadId)
+      return `Thread ${threadId} has been marked as completed`
+    },
+  }
+}
+
+/**
+ * Creates an AxFunction for deleting a thread
+ */
+export function deleteThreadFunction(
+  arena: Readonly<AxArena>,
+  threadId: string
+): AxFunction {
+  return {
+    name: 'deleteThread',
+    description: `Delete thread ${threadId} permanently from the arena`,
+    parameters: {
+      type: 'object',
+      properties: {},
+      required: [],
+    },
+    func: async () => {
+      const deleted = arena.deleteThread(threadId)
+      if (deleted) {
+        return `Thread ${threadId} has been deleted`
+      } else {
+        return `Thread with ID ${threadId} not found`
+      }
+    },
+  }
+}
+
+/**
+ * Creates an AxFunction for sending a message to a specific thread
+ */
+export function sendMessageFunction(
+  arena: Readonly<AxArena>,
+  threadId: string
+): AxFunction {
+  return {
+    name: 'sendMessage',
+    description: `Send a message to thread ${threadId}`,
+    parameters: {
+      type: 'object',
+      properties: {
+        content: {
+          type: 'string',
+          description: 'The content of the message to send',
+        },
+        sender: {
+          type: 'string',
+          description: 'The name of the sender (agent or user)',
+        },
+      },
+      required: ['content', 'sender'],
+    },
+    func: async ({
+      content,
+      sender,
+    }: Readonly<{ content: string; sender: string }>) => {
+      try {
+        await arena.sendMessage(threadId, content, sender)
+        return `Message sent successfully to thread ${threadId}`
+      } catch (error) {
+        return `Failed to send message: ${error instanceof Error ? error.message : 'Unknown error'}`
+      }
+    },
+  }
+}
+
+/**
+ * Creates an AxFunction for getting recent messages from a thread
+ */
+export function getMessagesFunction(
+  arena: Readonly<AxArena>,
+  threadId: string
+): AxFunction {
+  return {
+    name: 'getMessages',
+    description: `Get recent messages from thread ${threadId}`,
+    parameters: {
+      type: 'object',
+      properties: {
+        limit: {
+          type: 'number',
+          description:
+            'Maximum number of recent messages to retrieve (default: 10)',
+        },
+      },
+      required: [],
+    },
+    func: async ({
+      limit = 10,
+    }: {
+      limit?: number
+    } = {}) => {
+      const thread = arena.getThread(threadId)
+      if (!thread) {
+        return `Thread with ID ${threadId} not found`
+      }
+      const recentMessages = thread.messages.slice(-limit)
+      return JSON.stringify(recentMessages, null, 2)
+    },
+  }
+}
+
+/**
+ * Helper function to create all arena control functions for a specific thread
+ */
+export function createArenaControlFunctions(
+  arena: Readonly<AxArena>,
+  threadId: string
+): AxFunction[] {
+  return [
+    getThreadFunction(arena, threadId),
+    getAgentsFunction(arena, threadId),
+    pauseThreadFunction(arena, threadId),
+    resumeThreadFunction(arena, threadId),
+    completeThreadFunction(arena, threadId),
+    deleteThreadFunction(arena, threadId),
+    sendMessageFunction(arena, threadId),
+    getMessagesFunction(arena, threadId),
+  ]
+}
+
+/**
+ * Helper function to create general arena functions (not thread-specific)
+ */
+export function createGeneralArenaFunctions(arena: AxArena): AxFunction[] {
+  return [getAllThreadsFunction(arena)]
+}
diff --git a/src/ax/arena/index.ts b/src/ax/arena/index.ts
new file mode 100644
index 00000000..b5330ae4
--- /dev/null
+++ b/src/ax/arena/index.ts
@@ -0,0 +1,34 @@
+export { AxArena } from './arena.js'
+export {
+  getThreadFunction,
+  getAllThreadsFunction,
+  getAgentsFunction,
+  pauseThreadFunction,
+  resumeThreadFunction,
+  completeThreadFunction,
+  deleteThreadFunction,
+  sendMessageFunction,
+  getMessagesFunction,
+  createArenaControlFunctions,
+  createGeneralArenaFunctions,
+} from './control.js'
+
+export {
+  createArenaContextConsolidator,
+  createArenaRoutingAgent,
+  processMessageAndRoute,
+} from './router.js'
+export type {
+  AxArenaMessageAttachment,
+  AxArenaConfig,
+  AxArenaConsolidatorInput,
+  AxArenaConsolidatorOutput,
+  AxArenaEvent,
+  AxArenaManagerControls,
+  AxArenaMessage,
+  AxArenaResponse,
+  AxArenaRoutingInput,
+  AxArenaRoutingOutput,
+  AxArenaSendMessageOptions,
+  AxArenaThread,
+} from './types.js'
diff --git a/src/ax/arena/router.ts b/src/ax/arena/router.ts
new file mode 100644
index 00000000..ee3081b4
--- /dev/null
+++ b/src/ax/arena/router.ts
@@ -0,0 +1,381 @@
+import { randomUUID } from 'crypto'
+
+import { AxAgent } from '../prompts/agent.js'
+import type { AxAgentic } from '../prompts/agent.js'
+
+import type {
+  AxArenaConsolidatorInput,
+  AxArenaConsolidatorOutput,
+  AxArenaExecutionPlan,
+  AxArenaPlanningInput,
+  AxArenaPlanningOutput,
+  AxArenaTask,
+  AxArenaTaskManagerInput,
+  AxArenaTaskManagerOutput,
+} from './types.js'
+
+/**
+ * Creates an AxAgent that serves as a context consolidator for the arena
+ * It takes in an array of messages and outputs a consolidated task
+ */
+export function createArenaContextConsolidator(): AxAgent<
+  AxArenaConsolidatorInput,
+  AxArenaConsolidatorOutput
+> {
+  return new AxAgent({
+    name: 'Arena Context Consolidator',
+    description:
+      'Consolidates chat conversation messages into a clear, actionable task',
+    signature: `messages "chat conversation as string", threadTask "original thread task" -> consolidatedTask:string "clear consolidated task based on conversation"`,
+    definition: `You are a context consolidator for a multi-agent arena. Your job is to analyze a conversation thread and consolidate it into a clear, actionable task.
+
+CONSOLIDATION PRINCIPLES:
+1. Read through all the messages in the conversation
+2. Understand the original thread task and current context
+3. Identify what specific action or response is needed right now
+4. Create a clear, specific task that captures the current need
+
+TASK CREATION GUIDELINES:
+- Be specific about what needs to be done
+- Include relevant context from the conversation
+- Focus on the most recent request or need
+- Make it actionable for planning and execution
+- Keep it concise but comprehensive
+
+Your consolidated task will be passed to a planning agent to create a detailed execution plan.`,
+  })
+}
+
+/**
+ * Creates an AxAgent that serves as a planning agent for the arena
+ * It takes consolidated tasks and creates detailed step-by-step plans
+ */
+export function createArenaPlanningAgent(
+  getAgentInfo: () => Array<{ id: string; name: string; description: string }>
+): AxAgent<AxArenaPlanningInput, AxArenaPlanningOutput> {
+  return new AxAgent({
+    name: 'Arena Planning Agent',
+    description:
+      'Creates detailed step-by-step execution plans for consolidated tasks',
+    signature: `consolidatedTask "task to plan", threadTask "original thread task", availableAgents "available agents info" -> plan:string "detailed execution plan", steps:string "structured step list with dependencies"`,
+    functions: [
+      {
+        name: 'getAvailableAgents',
+        description: 'Get information about available agents in the arena',
+        parameters: {
+          type: 'object',
+          properties: {},
+          required: [],
+        },
+        func: async () => {
+          return JSON.stringify(getAgentInfo())
+        },
+      },
+    ],
+    definition: `You are an intelligent planning agent for a multi-agent arena. Your job is to break down complex tasks into detailed, executable steps.
+
+PLANNING PRINCIPLES:
+1. Use the getAvailableAgents function to understand available capabilities
+2. Break down the consolidated task into logical, sequential steps
+3. Assign each step to the most appropriate agent based on their expertise
+4. Consider dependencies between steps and plan accordingly
+5. Create clear, actionable steps that agents can execute independently
+
+STEP STRUCTURE:
+For each step, provide:
+- Step ID (unique identifier)
+- Description (clear, actionable task)
+- Assigned Agent (based on expertise match)
+- Dependencies (which steps must complete first)
+
+PLANNING GUIDELINES:
+- Start with information gathering and analysis steps
+- Follow with implementation or development steps
+- Include validation, testing, or review steps
+- End with documentation or summary steps
+- Consider parallel execution where possible
+- Ensure each step has clear success criteria
+
+Return a structured plan with numbered steps and clear dependencies.`,
+  })
+}
+
+/**
+ * Creates an AxAgent that serves as a task manager for the arena
+ * It manages task execution and routes individual tasks to appropriate agents
+ */
+export function createArenaTaskManager(
+  getAgentInfo: () => Array<{ id: string; name: string; description: string }>
+): AxAgent<AxArenaTaskManagerInput, AxArenaTaskManagerOutput> {
+  return new AxAgent({
+    name: 'Arena Task Manager',
+    description:
+      'Manages task execution and routes individual tasks to the best agents',
+    signature: `currentTask "current task to execute", taskId "task identifier", planContext "context from execution plan" -> agentId:string "ID of the selected agent"`,
+    functions: [
+      {
+        name: 'getAvailableAgents',
+        description: 'Get information about available agents in the arena',
+        parameters: {
+          type: 'object',
+          properties: {},
+          required: [],
+        },
+        func: async () => {
+          return JSON.stringify(getAgentInfo())
+        },
+      },
+    ],
+    definition: `You are a task manager for a multi-agent arena. Your job is to select the best agent for each individual task in an execution plan.
+
+TASK ROUTING PRINCIPLES:
+1. Use the getAvailableAgents function to see available agent capabilities
+2. Match the current task requirements to agent specializations
+3. Consider the broader plan context and dependencies
+4. Select the single best agent for this specific task
+
+AGENT SELECTION CRITERIA:
+- Match task keywords to agent specializations
+- Consider the type of work needed (architecture, coding, testing, etc.)
+- Think about required expertise and domain knowledge
+- Choose the most specialized agent for the task
+- Ensure agent can deliver the expected outputs
+
+You MUST call the getAvailableAgents function first, then return the ID of exactly one agent that should handle the current task.`,
+  })
+}
+
+/**
+ * Parses a plan string into structured tasks
+ */
+export function parsePlanIntoTasks(
+  planText: string,
+  stepsText: string,
+  agents: readonly AxAgentic[],
+  consolidatedTask: string
+): readonly AxArenaTask[] {
+  const tasks: AxArenaTask[] = []
+  const now = new Date()
+
+  // Simple parsing logic - in a real implementation, this would be more sophisticated
+  // For now, we'll create a basic structure based on the plan
+
+  // Parse steps from the plan text
+  const stepLines = stepsText
+    .split('\n')
+    .filter(
+      (line) =>
+        line.trim().length > 0 && (line.includes('Step') || line.includes('-'))
+    )
+
+  stepLines.forEach((line, index) => {
+    const stepId = `step-${index + 1}`
+    const description = line
+      .replace(/^\d+\.?\s*/, '')
+      .replace(/^-\s*/, '')
+      .trim()
+
+    // Simple agent assignment based on keywords
+    let assignedAgent = agents[0] // fallback
+    const lowerDescription = description.toLowerCase()
+
+    for (const agent of agents) {
+      const agentName = agent.getFunction().name.toLowerCase()
+      const agentDesc = agent.getFunction().description.toLowerCase()
+
+      // Check for keyword matches
+      const agentKeywords = [...agentName.split(' '), ...agentDesc.split(' ')]
+      const hasMatch = agentKeywords.some(
+        (keyword) =>
+          keyword.length > 3 && lowerDescription.includes(keyword.toLowerCase())
+      )
+
+      if (hasMatch) {
+        assignedAgent = agent
+        break
+      }
+    }
+
+    const task: AxArenaTask = {
+      id: stepId,
+      description: description || `Execute step ${index + 1} of the plan`,
+      assignedAgentId: index.toString(),
+      assignedAgentName: assignedAgent?.getFunction().name || 'Unknown Agent',
+      status: 'pending',
+      dependencies: index > 0 ? [`step-${index}`] : [], // Simple sequential dependency
+      createdAt: now,
+    }
+
+    tasks.push(task)
+  })
+
+  // If no steps were parsed, create a single task
+  if (tasks.length === 0) {
+    tasks.push({
+      id: 'step-1',
+      description: consolidatedTask,
+      assignedAgentId: '0',
+      assignedAgentName: agents[0]?.getFunction().name || 'Unknown Agent',
+      status: 'pending',
+      dependencies: [],
+      createdAt: now,
+    })
+  }
+
+  return tasks
+}
+
+/**
+ * Creates an execution plan from consolidated task using planning agent
+ */
+export async function createExecutionPlan(
+  planningAgent: Readonly<AxAgent<AxArenaPlanningInput, AxArenaPlanningOutput>>,
+  consolidatedTask: string,
+  threadTask: string,
+  agents: readonly AxAgentic[]
+): Promise<AxArenaExecutionPlan> {
+  try {
+    // Simple plan generation for demonstration
+    const planText = `Execution Plan for: ${consolidatedTask}
+
+This plan breaks down the task into manageable steps that can be executed by specialized agents.`
+
+    const stepsText = `Step 1: Analyze requirements and design approach
+Step 2: Implement the core solution
+Step 3: Optimize and refine the implementation
+Step 4: Test and validate the solution
+Step 5: Document the results and create usage guide`
+
+    const tasks = parsePlanIntoTasks(
+      planText,
+      stepsText,
+      agents,
+      consolidatedTask
+    )
+
+    const plan: AxArenaExecutionPlan = {
+      id: randomUUID(),
+      consolidatedTask,
+      tasks: [...tasks], // Convert readonly array to mutable for plan
+      status: 'pending',
+      createdAt: new Date(),
+    }
+
+    return plan
+  } catch {
+    // Fallback plan on error
+    const fallbackPlan: AxArenaExecutionPlan = {
+      id: randomUUID(),
+      consolidatedTask,
+      tasks: [
+        {
+          id: 'fallback-1',
+          description: consolidatedTask,
+          assignedAgentId: '0',
+          assignedAgentName: agents[0]?.getFunction().name || 'Unknown Agent',
+          status: 'pending',
+          dependencies: [],
+          createdAt: new Date(),
+        },
+      ],
+      status: 'pending',
+      createdAt: new Date(),
+    }
+
+    return fallbackPlan
+  }
+}
+
+/**
+ * Executes the next available task in the plan
+ */
+export async function executeNextTask(
+  taskManager: Readonly<
+    AxAgent<AxArenaTaskManagerInput, AxArenaTaskManagerOutput>
+  >,
+  plan: Readonly<AxArenaExecutionPlan>,
+  agents: readonly AxAgentic[]
+): Promise<{ task: AxArenaTask | null; selectedAgent: AxAgentic | null }> {
+  try {
+    // Find the next task to execute
+    const nextTask = plan.tasks.find((task) => {
+      if (task.status !== 'pending') return false
+
+      // Check if all dependencies are completed
+      const dependenciesCompleted = task.dependencies.every(
+        (depId) =>
+          plan.tasks.find((t) => t.id === depId)?.status === 'completed'
+      )
+
+      return dependenciesCompleted
+    })
+
+    if (!nextTask) {
+      return { task: null, selectedAgent: null }
+    }
+
+    // Find agent by assigned ID
+    const agentIndex = parseInt(nextTask.assignedAgentId)
+    const selectedAgent = agents[agentIndex] || agents[0] || null
+
+    // Update task status (note: this modifies the original task object)
+    nextTask.status = 'in-progress'
+    nextTask.startedAt = new Date()
+
+    // Update plan status
+    if (plan.status === 'pending') {
+      ;(plan as AxArenaExecutionPlan).status = 'in-progress'
+      ;(plan as AxArenaExecutionPlan).startedAt = new Date()
+    }
+    ;(plan as AxArenaExecutionPlan).currentTaskId = nextTask.id
+
+    return { task: nextTask, selectedAgent }
+  } catch {
+    return { task: null, selectedAgent: null }
+  }
+}
+
+/**
+ * Marks a task as completed and updates the plan
+ */
+export function completeTask(
+  plan: Readonly<AxArenaExecutionPlan>,
+  taskId: string,
+  result: string
+): void {
+  const task = plan.tasks.find((t) => t.id === taskId)
+  if (task) {
+    task.status = 'completed'
+    task.completedAt = new Date()
+    task.result = result
+  }
+
+  // Check if all tasks are completed
+  const allCompleted = plan.tasks.every((t) => t.status === 'completed')
+  if (allCompleted) {
+    // Note: These are mutable operations on the plan object
+    ;(plan as AxArenaExecutionPlan).status = 'completed'
+    ;(plan as AxArenaExecutionPlan).completedAt = new Date()
+    ;(plan as AxArenaExecutionPlan).currentTaskId = undefined
+  }
+}
+
+/**
+ * Marks a task as failed and updates the plan
+ */
+export function failTask(
+  plan: Readonly<AxArenaExecutionPlan>,
+  taskId: string,
+  error: string
+): void {
+  const task = plan.tasks.find((t) => t.id === taskId)
+  if (task) {
+    task.status = 'failed'
+    task.completedAt = new Date()
+    task.error = error
+  }
+
+  // Mark plan as failed if any critical task fails
+  ;(plan as AxArenaExecutionPlan).status = 'failed'
+  ;(plan as AxArenaExecutionPlan).completedAt = new Date()
+}
diff --git a/src/ax/arena/types.ts b/src/ax/arena/types.ts
new file mode 100644
index 00000000..a5676eb5
--- /dev/null
+++ b/src/ax/arena/types.ts
@@ -0,0 +1,267 @@
+import type { AxAgentic } from '../prompts/agent.js'
+
+/**
+ * Represents an attachment in an arena message
+ */
+export type AxArenaMessageAttachment = {
+  /** Unique identifier for the attachment */
+  id: string
+  /** Original filename */
+  filename: string
+  /** File size in bytes */
+  size: number
+  /** MIME type of the attachment */
+  mimeType: string
+  /** Type of attachment */
+  type: 'text' | 'image' | 'audio' | 'file'
+  /** Base64 encoded data or file path */
+  data: string
+  /** Optional description or alt text */
+  description?: string
+  /** Additional metadata */
+  metadata?: Record<string, unknown>
+}
+
+/**
+ * Represents a message in the arena thread
+ */
+export interface AxArenaMessage {
+  /** Unique identifier for the message */
+  id: string
+  /** ID of the thread this message belongs to */
+  threadId: string
+  /** Name of the agent or user who sent the message */
+  sender: string
+  /** The message content as plain text */
+  content: string
+  /** Optional attachments (files, images, etc.) */
+  attachments?: AxArenaMessageAttachment[]
+  /** Timestamp when the message was created */
+  timestamp: Date
+  /** Optional labels */
+  labels?: string[]
+  /** ID of the message this is responding to, if any */
+  replyTo?: string
+}
+
+/**
+ * Represents a thread in the arena
+ */
+export interface AxArenaThread {
+  /** Unique identifier for the thread */
+  id: string
+  /** The initial task or prompt that started the thread */
+  task: string
+  /** List of participating agents */
+  agents: AxAgentic[]
+  /** All messages in the thread */
+  messages: AxArenaMessage[]
+  /** Current status of the thread */
+  status: 'active' | 'paused' | 'completed' | 'error'
+  /** Timestamp when the thread was created */
+  createdAt: Date
+  /** Timestamp when the thread was last updated */
+  updatedAt: Date
+  /** Optional metadata */
+  metadata?: Record<string, unknown>
+}
+
+/**
+ * Configuration for the AxArena
+ */
+export interface AxArenaConfig {
+  /** Maximum number of messages per thread */
+  maxMessagesPerThread?: number
+  /** Maximum number of concurrent threads */
+  maxConcurrentThreads?: number
+  /** Whether to enable debug logging */
+  debug?: boolean
+}
+
+/**
+ * Options for sending a message to the arena
+ */
+export interface AxArenaSendMessageOptions {
+  /** Specific agents to target (if not provided, arena manager will decide) */
+  targetAgents?: string[]
+  /** Whether to wait for responses before returning */
+  waitForResponses?: boolean
+  /** Maximum time to wait for responses in milliseconds */
+  responseTimeout?: number
+  /** Additional metadata to attach to the message */
+  metadata?: Record<string, unknown>
+}
+
+/**
+ * Response from the arena after processing a message
+ */
+export interface AxArenaResponse {
+  /** The original message that was sent */
+  originalMessage: AxArenaMessage
+  /** Responses from agents */
+  responses: AxArenaMessage[]
+  /** Agents that were selected to respond */
+  selectedAgents: string[]
+  /** Processing time in milliseconds */
+  processingTime: number
+}
+
+/**
+ * Event emitted by the arena
+ */
+export interface AxArenaEvent {
+  /** Type of event */
+  type: 'message' | 'response' | 'threadCreated' | 'thread_updated' | 'error'
+  /** Thread ID the event relates to */
+  threadId: string
+  /** Event data */
+  data: unknown
+  /** Timestamp of the event */
+  timestamp: Date
+}
+
+/**
+ * Arena manager control functions available to the arena manager agent
+ */
+export interface AxArenaManagerControls {
+  /** Get information about all agents in the arena */
+  getAgentInfo: () => Array<{
+    name: string
+    description: string
+    features: Record<string, unknown>
+  }>
+
+  /** Get the current thread state */
+  getThreadState: () => AxArenaThread
+
+  /** Get recent messages from the thread */
+  getRecentMessages: (count?: number) => AxArenaMessage[]
+
+  /** Route a message to specific agents */
+  routeToAgents: (
+    agentNames: string[],
+    message: string
+  ) => Promise<AxArenaMessage[]>
+
+  /** Send a system message to the thread */
+  sendSystemMessage: (content: string) => AxArenaMessage
+
+  /** Update thread metadata */
+  updateThreadMetadata: (metadata: Record<string, unknown>) => void
+
+  /** Pause or resume the thread */
+  setThreadStatus: (status: AxArenaThread['status']) => void
+}
+
+/**
+ * Input type for the context consolidator agent
+ */
+export interface AxArenaConsolidatorInput {
+  messages: string
+  threadTask: string
+}
+
+/**
+ * Output type for the context consolidator agent
+ */
+export interface AxArenaConsolidatorOutput {
+  consolidatedTask: string
+}
+
+/**
+ * Input type for the planning agent
+ */
+export interface AxArenaPlanningInput {
+  consolidatedTask: string
+  threadTask: string
+  availableAgents: string
+}
+
+/**
+ * Output type for the planning agent
+ */
+export interface AxArenaPlanningOutput {
+  plan: string
+  steps: string
+}
+
+/**
+ * Represents a single task/step in the execution plan
+ */
+export interface AxArenaTask {
+  /** Unique identifier for the task */
+  id: string
+  /** Task description */
+  description: string
+  /** Agent assigned to this task */
+  assignedAgentId: string
+  /** Agent name assigned to this task */
+  assignedAgentName: string
+  /** Current status of the task */
+  status: 'pending' | 'in-progress' | 'completed' | 'failed'
+  /** Dependencies - task IDs that must be completed first */
+  dependencies: string[]
+  /** When the task was created */
+  createdAt: Date
+  /** When the task was started */
+  startedAt?: Date
+  /** When the task was completed */
+  completedAt?: Date
+  /** Task result/output */
+  result?: string
+  /** Error message if task failed */
+  error?: string
+}
+
+/**
+ * Represents a complete execution plan
+ */
+export interface AxArenaExecutionPlan {
+  /** Unique identifier for the plan */
+  id: string
+  /** Original consolidated task */
+  consolidatedTask: string
+  /** All tasks in the plan */
+  tasks: AxArenaTask[]
+  /** Current status of the plan */
+  status: 'pending' | 'in-progress' | 'completed' | 'failed'
+  /** When the plan was created */
+  createdAt: Date
+  /** When the plan was started */
+  startedAt?: Date
+  /** When the plan was completed */
+  completedAt?: Date
+  /** Current task being executed */
+  currentTaskId?: string
+}
+
+/**
+ * Input type for the task manager (renamed routing agent)
+ */
+export interface AxArenaTaskManagerInput {
+  currentTask: string
+  taskId: string
+  planContext: string
+}
+
+/**
+ * Output type for the task manager
+ */
+export interface AxArenaTaskManagerOutput {
+  agentId: string
+}
+
+/**
+ * Input type for the arena routing manager (legacy - keeping for compatibility)
+ */
+export interface AxArenaRoutingInput {
+  consolidatedTask: string
+  threadTask: string
+}
+
+/**
+ * Output type for the arena routing manager (legacy - keeping for compatibility)
+ */
+export interface AxArenaRoutingOutput {
+  agentId: string
+}
diff --git a/src/ax/index.ts b/src/ax/index.ts
index 12f693ce..3cd6d5e0 100644
--- a/src/ax/index.ts
+++ b/src/ax/index.ts
@@ -483,6 +483,26 @@ import {
   type AxRateLimiterFunction,
   type AxTokenUsage
 } from './ai/types.js';
+import {
+  type AxArenaConfig,
+  type AxArenaConsolidatorInput,
+  type AxArenaConsolidatorOutput,
+  type AxArenaEvent,
+  type AxArenaExecutionPlan,
+  type AxArenaManagerControls,
+  type AxArenaMessage,
+  type AxArenaMessageAttachment,
+  type AxArenaPlanningInput,
+  type AxArenaPlanningOutput,
+  type AxArenaResponse,
+  type AxArenaRoutingInput,
+  type AxArenaRoutingOutput,
+  type AxArenaSendMessageOptions,
+  type AxArenaTask,
+  type AxArenaTaskManagerInput,
+  type AxArenaTaskManagerOutput,
+  type AxArenaThread
+} from './arena/types.js';
 import {
   type AxDBQueryRequest,
   type AxDBQueryResponse,
@@ -505,6 +525,7 @@ import {
 import {AxAIDeepSeekModel} from './ai/deepseek/types.js';
 import {AxAIGroqModel} from './ai/groq/types.js';
 import {AxAIOpenAIResponsesImpl} from './ai/openai/responses_api.js';
+import {AxArena} from './arena/arena.js';
 import {AxChainOfThought} from './prompts/cot.js';
 import {AxDefaultResultReranker} from './docs/reranker.js';
 import {AxEmbeddingAdapter} from './funcs/embed.js';
@@ -579,6 +600,7 @@ export { AxAIServiceTimeoutError };
 export { AxAITogether };
 export { AxAgent };
 export { AxApacheTika };
+export { AxArena };
 export { AxAssertionError };
 export { AxBalancer };
 export { AxBaseAI };
@@ -850,6 +872,24 @@ export type { AxAgentOptions };
 export type { AxAgentic };
 export type { AxApacheTikaArgs };
 export type { AxApacheTikaConvertOptions };
+export type { AxArenaConfig };
+export type { AxArenaConsolidatorInput };
+export type { AxArenaConsolidatorOutput };
+export type { AxArenaEvent };
+export type { AxArenaExecutionPlan };
+export type { AxArenaManagerControls };
+export type { AxArenaMessage };
+export type { AxArenaMessageAttachment };
+export type { AxArenaPlanningInput };
+export type { AxArenaPlanningOutput };
+export type { AxArenaResponse };
+export type { AxArenaRoutingInput };
+export type { AxArenaRoutingOutput };
+export type { AxArenaSendMessageOptions };
+export type { AxArenaTask };
+export type { AxArenaTaskManagerInput };
+export type { AxArenaTaskManagerOutput };
+export type { AxArenaThread };
 export type { AxAssertion };
 export type { AxBalancerOptions };
 export type { AxBaseAIArgs };
diff --git a/src/examples/arena.ts b/src/examples/arena.ts
new file mode 100644
index 00000000..2a9b438a
--- /dev/null
+++ b/src/examples/arena.ts
@@ -0,0 +1,332 @@
+import {
+  AxAgent,
+  AxAI,
+  AxAIOpenAIModel,
+  AxArena,
+  type AxArenaEvent,
+  type AxArenaMessage,
+} from '@ax-llm/ax'
+
+// Initialize AI instance (will use environment variables)
+const ai = new AxAI({
+  name: 'openai',
+  apiKey: process.env.OPENAI_APIKEY as string,
+  config: {
+    model: AxAIOpenAIModel.GPT35Turbo,
+  },
+})
+
+// Create specialized story writing agents with AI
+const worldBuilder = new AxAgent({
+  ai,
+  name: 'World Builder',
+  description:
+    'Expert in creating rich fictional worlds, settings, and backgrounds',
+  signature: `storyRequirements "story requirements and genre" -> worldDescription:string "detailed world setting", characters:string "main characters overview"`,
+})
+
+const plotDeveloper = new AxAgent({
+  ai,
+  name: 'Plot Developer',
+  description:
+    'Specialized in crafting compelling storylines, plot structures, and narrative arcs',
+  signature: `worldDescription "world setting", characters "character descriptions" -> plotOutline:string "detailed plot structure", conflicts:string "main conflicts and tensions"`,
+})
+
+const dialogueWriter = new AxAgent({
+  ai,
+  name: 'Dialogue Writer',
+  description:
+    'Expert in writing natural, engaging dialogue and character interactions',
+  signature: `plotOutline "plot structure", characters "character descriptions" -> dialogue:string "sample dialogue scenes", characterVoices:string "unique voice for each character"`,
+})
+
+const narrativeWriter = new AxAgent({
+  ai,
+  name: 'Narrative Writer',
+  description:
+    'Specialized in descriptive writing, scene setting, and narrative flow',
+  signature: `plotOutline "plot outline", worldDescription "world setting" -> narrative:string "narrative passages", sceneDescriptions:string "vivid scene descriptions"`,
+})
+
+const editor = new AxAgent({
+  ai,
+  name: 'Story Editor',
+  description: 'Expert in story editing, pacing, consistency, and final polish',
+  signature: `story "complete story draft", plotOutline "original plot" -> editedStory:string "polished final story", improvements:string "editing suggestions and changes"`,
+})
+
+// Create the story writing arena
+const storyArena = new AxArena({
+  maxMessagesPerThread: 50,
+  maxConcurrentThreads: 3,
+  debug: true,
+})
+
+// Story project examples
+const storyProject = {
+  genre: 'Science Fiction',
+  theme: 'First Contact',
+  requirements: `
+      - Short story (1000-1500 words)
+      - Near-future setting (50 years from now)
+      - Focus on the emotional impact of first contact with aliens
+      - Include both human and alien perspectives
+      - Themes of communication, understanding, and connection
+    `,
+  complexity: 'Medium',
+}
+
+async function demonstrateStoryArena() {
+  console.log('📚 Collaborative Story Writing Arena')
+  console.log('='.repeat(60))
+
+  // Check if AI is properly configured
+  if (!process.env.OPENAI_APIKEY) {
+    console.log('⚠️  Warning: No OPENAI_APIKEY found in environment variables')
+  }
+
+  // Create specialized writing team
+  const agents = [
+    worldBuilder,
+    plotDeveloper,
+    dialogueWriter,
+    narrativeWriter,
+    editor,
+  ]
+
+  console.log('👥 Specialized Writing Team:')
+  agents.forEach((agent) => {
+    const func = agent.getFunction()
+    console.log(`• ${func.name}: ${func.description}`)
+  })
+  console.log()
+
+  // Select a story project to work on
+  const project = storyProject
+
+  // Create writing thread
+  const thread = storyArena.createThread(
+    agents,
+    `Create a compelling ${project.genre.toLowerCase()} story about ${project.theme.toLowerCase()}`,
+    {
+      metadata: {
+        genre: project.genre,
+        theme: project.theme,
+        requirements: project.requirements,
+        targetLength: '1000-1500 words',
+        deadline: '2024-02-01',
+      },
+    }
+  )
+
+  console.log(`📝 Created writing thread: ${thread.id}`)
+  console.log(`📖 Genre: ${project.genre}`)
+  console.log(`🎭 Theme: ${project.theme}`)
+  console.log(`📋 Requirements:${project.requirements}`)
+  console.log()
+
+  // Listen to writing events
+  storyArena.on('message', (event: AxArenaEvent) => {
+    console.log(`📨 New message in thread ${event.threadId}`)
+  })
+
+  storyArena.on('response', (event: AxArenaEvent) => {
+    const message = event.data as AxArenaMessage
+    console.log(`✍️  ${message.sender}:`)
+    console.log(`   ${message.content.substring(0, 150)}...`)
+    console.log()
+  })
+
+  console.log('🔄 Starting collaborative story writing workflow...')
+  console.log()
+
+  try {
+    // Send a comprehensive story writing request
+    const storyRequest = `Create a compelling science fiction story about first contact with the following requirements:
+
+    Genre: Science Fiction
+    Theme: First Contact with Alien Life
+    Setting: Near future (circa 2075)
+    Length: 1000-1500 words
+    
+    Story Elements:
+    - Emotional focus on the human experience of first contact
+    - Include both human and alien perspectives if possible
+    - Themes of communication, understanding, and hope
+    - Realistic near-future technology
+    - Strong character development
+    - Surprising but logical resolution
+    
+    Please create a complete, polished story with rich world-building, engaging characters, and compelling narrative.`
+
+    console.log('📝 Sending story request to writing team...')
+    console.log(
+      `💭 Request: Create a science fiction story about first contact...`
+    )
+    console.log()
+
+    const response = await storyArena.sendMessage(
+      thread.id,
+      storyRequest,
+      'client'
+    )
+
+    console.log(
+      `✅ Story creation completed! Writers executed ${response.selectedAgents.length} tasks`
+    )
+    console.log(`✍️  Writers involved: ${response.selectedAgents.join(', ')}`)
+    console.log(`⏱️  Total writing time: ${response.processingTime}ms`)
+    console.log()
+
+    // Show the execution plan details
+    const plan = storyArena.getExecutionPlan(thread.id)
+    if (plan) {
+      console.log('📊 Writing Plan Details:')
+      console.log(`   Plan ID: ${plan.id}`)
+      console.log(`   Status: ${plan.status}`)
+      console.log(`   Total Tasks: ${plan.tasks.length}`)
+      console.log(
+        `   Completed Tasks: ${plan.tasks.filter((t) => t.status === 'completed').length}`
+      )
+      console.log()
+
+      console.log('📋 Writing Process Breakdown:')
+      plan.tasks.forEach((task, index) => {
+        const statusIcon =
+          task.status === 'completed'
+            ? '✅'
+            : task.status === 'in-progress'
+              ? '🔄'
+              : task.status === 'failed'
+                ? '❌'
+                : '⏳'
+        console.log(`   ${index + 1}. ${statusIcon} ${task.description}`)
+        console.log(`      └── Writer: ${task.assignedAgentName}`)
+        console.log(`      └── Status: ${task.status}`)
+        if (task.result) {
+          console.log(`      └── Output: ${task.result.substring(0, 100)}...`)
+        }
+        console.log()
+      })
+    }
+
+    // Demonstrate follow-up revision request
+    console.log('🔄 Sending revision request...')
+    const revisionRequest =
+      'Please revise the story to add more emotional depth to the first contact moment and enhance the alien perspective.'
+
+    const followUpResponse = await storyArena.sendMessage(
+      thread.id,
+      revisionRequest,
+      'editor'
+    )
+
+    console.log(
+      `✅ Revision completed with ${followUpResponse.selectedAgents.length} additional tasks`
+    )
+    console.log(`⏱️  Revision time: ${followUpResponse.processingTime}ms`)
+  } catch (error) {
+    console.error(`❌ Error in story writing workflow: ${error}`)
+  }
+
+  // Display final story summary
+  const finalThread = storyArena.getThread(thread.id)
+  if (finalThread) {
+    console.log('\n📖 Story Writing Session Summary:')
+    console.log(`   Genre: ${project.genre}`)
+    console.log(`   Theme: ${project.theme}`)
+    console.log(`   Total messages: ${finalThread.messages.length}`)
+    console.log(`   Thread status: ${finalThread.status}`)
+    console.log(
+      `   Writing session duration: ${finalThread.updatedAt.getTime() - finalThread.createdAt.getTime()}ms`
+    )
+
+    // Writer participation summary
+    const writerParticipation = agents.reduce(
+      (acc, agent) => {
+        const agentName = agent.getFunction().name
+        const responseCount = finalThread.messages.filter(
+          (m) => m.sender === agentName
+        ).length
+        acc[agentName] = responseCount
+        return acc
+      },
+      {} as Record<string, number>
+    )
+
+    console.log('\n👥 Writer Participation:')
+    Object.entries(writerParticipation).forEach(([writer, count]) => {
+      console.log(`   ${writer}: ${count} contributions`)
+    })
+
+    // Show writing timeline
+    console.log('\n📅 Writing Timeline:')
+    finalThread.messages
+      .filter((m) => m.sender !== 'system')
+      .slice(-6) // Show last 6 messages
+      .forEach((msg, index) => {
+        const timeFromStart =
+          msg.timestamp.getTime() - finalThread.createdAt.getTime()
+        console.log(`   ${index + 1}. [+${timeFromStart}ms] ${msg.sender}`)
+        console.log(`      ${msg.content.substring(0, 80)}...`)
+      })
+  }
+
+  console.log('\n🎉 Collaborative story writing session completed!')
+  console.log('📚 Ready for the next creative project!')
+}
+
+// Available story projects for demonstration
+function showAvailableProjects() {
+  console.log('\n📚 Available Story Projects:')
+  storyProjects.forEach((project, index) => {
+    console.log(`\n${index + 1}. ${project.genre}: ${project.theme}`)
+    console.log(`   Requirements: ${project.requirements.trim()}`)
+    console.log(`   Complexity: ${project.complexity}`)
+  })
+}
+
+// Writing analytics simulation
+async function simulateWritingAnalytics() {
+  console.log('\n📊 Writing Analytics Dashboard')
+  console.log('-'.repeat(40))
+
+  const analytics = {
+    'Story Completion Times': {
+      'World Building': '2.3 minutes',
+      'Plot Development': '3.1 minutes',
+      'Dialogue Writing': '2.8 minutes',
+      'Narrative Writing': '4.2 minutes',
+      'Final Editing': '1.9 minutes',
+    },
+    'Writer Efficiency': {
+      'World Builder': '92% accuracy',
+      'Plot Developer': '88% consistency',
+      'Dialogue Writer': '95% natural flow',
+      'Narrative Writer': '90% descriptive quality',
+      'Story Editor': '97% polish rate',
+    },
+  }
+
+  Object.entries(analytics).forEach(([category, metrics]) => {
+    console.log(`\n📈 ${category}:`)
+    Object.entries(metrics).forEach(([metric, value]) => {
+      console.log(`   ${metric}: ${value}`)
+    })
+  })
+}
+
+// Main execution
+async function main() {
+  await demonstrateStoryArena()
+  showAvailableProjects()
+  await simulateWritingAnalytics()
+}
+
+// Run the story writing arena demonstration
+if (import.meta.url.includes('arena.ts')) {
+  main().catch(console.error)
+}
+
+export { demonstrateStoryArena, storyProjects, storyArena }