🎯 Why AgentStack?

AgentStack bridges the gap between basic AI chatbots and enterprise-grade multi-agent orchestration. While other AI agent platforms offer simple automation, AgentStack delivers the observability, security, and scalability required for production deployment.

Feature	AgentStack	Fleece AI	Botpress	Vellum AI
Production Observability	✅ Real-time traces via TanStack + Langfuse ready	⚠️ Basic	⚠️ Basic	✅ Partial
Dataset Management	✅ Full dataset/eval/experiment API with versioning	❌ None	❌ None	⚠️ Basic
Supervisor Networks	✅ 12+ coordinator agents with delegation hooks	❌ None	❌ None	❌ None
Financial Intelligence	✅ Polygon/Finnhub/AlphaVantage (30+ endpoints)	❌ None	❌ None	❌ None
RAG Pipeline	✅ LibSQL HNSW + rerank + graphRAG	⚠️ Basic	⚠️ Basic	✅ External
Multi-Agent Orchestration	✅ A2A MCP + supervisor networks (25+ agents)	✅ Advanced	✅ Basic	✅ Partial
Live Browser Automation	✅ Local Chrome/CDP browser agent + shared runtime	⚠️ Basic	⚠️ Partial	⚠️ Partial
Workspaces / Sandboxes	✅ AgentFS + Daytona + local sandboxes + persistence	⚠️ Basic	❌ None	⚠️ Partial
Enterprise Security	✅ Better Auth + RBAC + path traversal protection + HTML sanitization	⚠️ Partial	⚠️ Partial	✅ Partial
Type Safety	✅ Zod schemas everywhere (57 tools)	⚠️ Limited	⚠️ Limited	✅ Partial
UI Components	✅ 105 components (AI Elements + shadcn/ui)	✅ 30+	✅ 50+	✅ 30+
Testing	✅ Vitest + 97% coverage + comprehensive mocks	⚠️ Partial	⚠️ Partial	✅ Partial

🚀 Production-Ready from Day One

While other AI agent platforms offer basic chatbot functionality, AgentStack provides enterprise-grade multi-agent orchestration:

• Zero-config RAG: LibSQL with 3072D embeddings works out of the box
• Supervisor Networks: 12+ coordinator agents with delegation hooks and scoring
• Workspace Management: AgentFS, Daytona, and local sandboxes with LSP support and LibSQL-backed persistence
• Financial Intelligence: Polygon, Finnhub, AlphaVantage with 30+ endpoints
• Full Observability: Every agent call, tool execution, and workflow step is traced
• Enterprise Security: Better Auth, RBAC, path validation, HTML sanitization, LibSQL session storage

✨ Core Capabilities

• 💰 Financial Intelligence: 30+ tools (Polygon quotes/aggs/fundamentals, Finnhub analysis, AlphaVantage indicators)
• 🔍 Semantic RAG: LibSQL (3072D embeddings) + MDocument chunking + rerank + graph traversal
• 📊 Dataset Management: Full dataset API with versioning, experiments, and evaluation
• 🤖 25+ Agents: Individual specialized agents (research, stock analysis, copywriting, etc.)
• 📋 10+ Workflows: Multi-step orchestrated processes (weather analysis, content creation, financial reports)
• 🌐 12+ Supervisor Networks: Coordinator agents that route tasks to specialized agents using delegation hooks (primary router, coding team, financial intelligence, content creation, etc.)
• 🧭 Live Browser Automation: Shared Chrome/CDP browser runtime for local verification, screenshots, and interaction testing
• 🧩 Workspaces & Sandboxes: AgentFS, Daytona, and local sandbox support with persistent LibSQL-backed state
• 🔌 A2A/MCP: MCP server coordinates parallel agents (research+stock→report), A2A coordinator for cross-agent communication
• 🎨 105 UI Components: AI Elements (50 chat/reasoning/canvas components) + shadcn/ui (55 base primitives)
• 📊 Enterprise Observability: Default tracing + Langfuse integration + 10+ custom scorers + middleware logging
• 🛡️ Enterprise Security: JWT auth, RBAC, path validation, HTML sanitization, secrets masking, middleware protection
• ⚡ Extensible: Model registry (Gemini/OpenAI/Anthropic/OpenRouter), Zod schemas everywhere, MastraClient SDK integration

⚛️ TanStack Query Integration

Production-grade data fetching with comprehensive React hooks:

// lib/hooks/use-mastra-query.ts - 1590+ lines of typed hooks
import { useAgentsQuery } from '@/lib/hooks/use-mastra-query'

export function AgentsDashboard() {
    const { data: agents, isLoading, error } = useAgentsQuery()

    // 15+ specialized hooks for agents, workflows, tools, memory, vectors
    // Automatic caching, background refetching, optimistic updates
    // Type-safe with Zod schemas throughout
}

Key Features:

• 1590+ Lines: Comprehensive hook coverage for all Mastra APIs
• Type Safety: Full TypeScript with Zod schema validation
• Caching: Intelligent cache management with React Query
• Real-time: Automatic background updates and invalidation
• DevTools: Integrated with @tanstack/react-query-devtools

📊 Dataset Management & Evaluation

Complete dataset and evaluation pipeline with versioning and experiments:

// lib/hooks/use-mastra-query.ts - Full dataset API
const { data: datasets } = useDatasets()
const { data: experiments } = useDatasetExperiments(datasetId)

// Dataset operations
const createDataset = useCreateDatasetMutation()
const addItems = useAddDatasetItemsMutation()
const runExperiment = useTriggerDatasetExperimentMutation()

Features:

• Dataset Versioning: Full history tracking and rollback capabilities
• Experiment Management: Compare model performance across datasets
• Evaluation Scorers: Custom scoring functions for quality assessment
• Batch Operations: Efficient bulk data operations
• Type Safety: Full TypeScript support with Zod validation

🔍 Observability & Monitoring

Enterprise-grade observability with easy Langfuse integration:

// src/mastra/index.ts - Default observability setup
observability: new Observability({
  configs: {
    default: {
      sampling: { type: SamplingStrategyType.RATIO, probability: 0.75 },
      spanOutputProcessors: [new SensitiveDataFilter({...})],
      exporters: [new DefaultExporter({...})],
      // Easy Langfuse integration: uncomment and configure
      // exporters: [new LangfuseExporter({...})],
    }
  }
})

Features:

• Default Tracing: Built-in observability with no setup required
• Real-time Trace Viewing: View traces in real-time via TanStack Query hooks
• Langfuse Ready: Drop-in integration for advanced analytics and persistence
• Custom Scorers: 10+ evaluation metrics for agent performance
• Sensitive Data Protection: Automatic redaction of credentials
• Performance Monitoring: Latency, token usage, error tracking

Real-time Trace Monitoring:

// View traces in real-time with TanStack hooks
const { data: traces } = useTraces({ limit: 10 })
const { data: trace } = useTrace(traceId)

// Monitor agent performance metrics
const { data: scores } = useScoresByRun({ runId })

🌐 Middleware & Request Context

AgentStack uses server-side Mastra middleware to populate request context for agents, tools, workflows, and supervisor routes. The frontend does not import these helpers directly.

// src/mastra/index.ts - Middleware configuration
middleware: [
  async (c, next) => {
    const authHeader = c.req.header('Authorization') ?? ''
    const requestContext = c.get('requestContext')

    const authenticatedUser = await getAuthenticatedUser({
      mastra,
      token: authHeader.startsWith('Bearer ')
        ? authHeader.slice('Bearer '.length)
        : '',
      request: c.req.raw,
    })

    if (requestContext?.set) {
      requestContext.set('userId', authenticatedUser?.user.id)
      requestContext.set(
        'role',
        authenticatedUser?.user.role === 'admin' ? 'admin' : 'user'
      )
      requestContext.set('language', 'en')
      requestContext.set('provider-id', 'google')
      requestContext.set(
        'model-id',
        'gemini-3.1-flash-lite-preview'
      )
    }

    await next()
  },
]

How it works:

• Server-only request context: defined in src/mastra/agents/request-context.ts
• Auth integration: src/mastra/auth.ts stores Better Auth data in LibSQL
• Role-based access: role is either admin or user
• Model overrides: provider-id and model-id can be passed through request context
• Workspace identity: workspaceId, threadId, and resourceId are reserved for server-side routing and persistence
• Localization: language and region can still be inferred server-side
• LibSQL fallback: Turso URLs are optional; if missing, the app falls back to local file:./database.db

🔧 Harness - Multi-Mode Agent Orchestration (Alpha)

Advanced multi-mode agent orchestration with state persistence and workspace management:

// src/mastra/harness.ts - 8 specialized agent modes
export const mainHarness = new Harness({
    id: 'agentstack-harness',
    resourceId: 'agentstack',
    storage: pgStore,
    workspace: mainWorkspace,

    modes: [
        { id: 'plan', name: 'Planner', agent: codeArchitectAgent },
        { id: 'code', name: 'Builder', agent: codeArchitectAgent },
        { id: 'review', name: 'Reviewer', agent: codeReviewerAgent },
        { id: 'test', name: 'Tester', agent: testEngineerAgent },
        { id: 'refactor', name: 'Refactorer', agent: refactoringAgent },
        { id: 'research', name: 'Researcher', agent: researchAgent },
        { id: 'edit', name: 'Editor', agent: editorAgent },
        { id: 'report', name: 'Reporter', agent: reportAgent },
    ],
})

Available Modes:

• 🏗️ Plan: Architecture and planning (codeArchitectAgent)
• 💻 Code: Implementation and coding (codeArchitectAgent)
• 🔍 Review: Code review and quality assessment (codeReviewerAgent)
• 🧪 Test: Test generation and validation (testEngineerAgent)
• 🔄 Refactor: Code refactoring and optimization (refactoringAgent)
• 🔬 Research: Research and information gathering (researchAgent)
• ✏️ Edit: Content editing and refinement (editorAgent)
• 📊 Report: Report generation and synthesis (reportAgent)

Key Features:

• State Persistence: Thread management with LibSQL storage
• Workspace Integration: Full filesystem and sandbox access
• Mode Switching: Dynamic agent mode transitions
• Tool Approvals: Security controls for sensitive operations
• Event Streaming: Real-time progress and result streaming

Usage (Alpha):

// Switch to planning mode
await harness.switchMode('plan')
await harness.execute('Design a new authentication system')

// Switch to implementation mode
await harness.switchMode('code')
await harness.execute('Implement the auth system using JWT')

// Switch to testing mode
await harness.switchMode('test')
await harness.execute('Generate comprehensive tests for auth')

⚠️ Alpha Status: The harness is currently in active development. APIs may change without notice.

🏗️ Workspace Management

Multi-provider workspace system with LSP support:

// src/mastra/workspaces.ts - 14 workspace variants
export const workspaceVariants = {
    mainWorkspace, // Local filesystem + sandbox
    agentFsWorkspace, // AgentFS integration
    daytonaWorkspace, // Daytona cloud sandboxes
    localReadOnlyWorkspace, // Read-only operations
    localApprovalWorkspace, // Manual approval required
    localLspWorkspace, // TypeScript/ESLint LSP
    // ... 8 more variants
}

Providers:

• Local: Filesystem and sandbox with process management
• AgentFS: Distributed filesystem with persistence
• Daytona: Cloud-based development environments
• LSP: TypeScript and ESLint language server integration
• Approval: Security-controlled operations

Features:

• Process Management: Spawn, kill, and monitor workspace processes
• LSP Integration: Real-time TypeScript/ESLint diagnostics
• Security Controls: Path validation and approval workflows
• Multi-tenant: Isolated workspaces with proper boundaries

🌟 Feature Highlights

💰 Financial Intelligence Suite

Real-time market data from 30+ endpoints:

// Example: Multi-source stock analysis
const analysis = await stockAnalysisAgent.execute({
    symbol: 'AAPL',
    includeFundamentals: true,
    includeNews: true,
    timeRange: '1Y',
})
// → Combines Polygon quotes, Finnhub analysis, AlphaVantage indicators
// → Returns: Price action, valuation metrics, sentiment analysis

Supported Data Providers:

• Polygon.io: Real-time quotes, historical aggregates, fundamentals
• Finnhub: Company profiles, insider transactions, earnings surprises
• Alpha Vantage: Technical indicators (RSI, MACD, Bollinger Bands)

🔍 Production RAG Pipeline

Zero-config semantic search with libSQL:

// 1. Index documents
await documentProcessingWorkflow.execute({
    documents: ['./annual-report.pdf', './market-data.csv'],
    chunkingStrategy: 'semantic',
    indexName: 'financial-reports',
})

// 2. Query with context
const answer = await governedRagAnswerWorkflow.execute({
    query: 'What were Q3 revenue drivers?',
    indexName: 'financial-reports',
    rerankTopK: 5,
})
// → Returns: Synthesized answer + source citations + confidence score

Features:

• 10 Chunking Strategies: Semantic, recursive, markdown-aware
• 3072D Embeddings: Gemini embedding-001
• Hybrid Search: Vector similarity + BM25 reranking
• Graph Traversal: Relationship-aware context expansion

🤖 Agent Networks (Supervisor Agents)

Supervisor agents that coordinate multiple specialized agents using delegation hooks:

// Networks are supervisor agents that route tasks to specialized subagents
const result = await agentNetwork.execute({
    query: 'Analyze renewable energy market trends',
    // Uses delegation hooks to route to researchAgent, learningAgent, etc.
})
// → Supervisor agent analyzes request and delegates to appropriate subagents
// → Results synthesized into unified response

Network Architecture:

• Supervisor Pattern: Networks are supervisor agents, not parallel execution
• Delegation Hooks: Use onDelegationStart/onDelegationComplete for coordination
• Scoring System: Custom scorers ensure task completion and synthesis quality
• Context Preservation: Maintain conversation context across delegations

Pre-configured Networks:

• Primary Network: Routes to research, stock, weather, content, support agents
• Coding Team Network: Architecture → Code Review → Testing → Refactoring
• Financial Intelligence Network: Research → Analysis → Charts → Reports
• Content Creation Network: Writing → Editing → Strategy → SEO

📊 Full Observability

Every operation traced with Langfuse:

// Traces automatically captured
const trace = await langfuse.getTrace(traceId)
// → Agent execution steps
// → Tool calls with latency
// → Token usage per step
// → Custom scorer results (quality, diversity, completeness)

Dashboard Views:

• Real-time trace visualization
• Performance metrics (latency, error rates)
• Cost tracking by agent/workflow
• Custom scorer analytics

🎨 AI Elements UI Library

50+ production-ready React components:

import { AgentArtifact, AgentChainOfThought, AgentSources } from '@/ai-elements'

// Render streaming AI responses
<AgentChainOfThought
  steps={reasoningSteps}
  isStreaming={true}
  duration={1500}
/>

// Display code artifacts with syntax highlighting
<AgentArtifact
  artifact={{
    type: 'code',
    language: 'typescript',
    content: generatedCode
  }}
  onCodeUpdate={handleUpdate}
/>

// Show source citations
<AgentSources
  sources={citedSources}
  maxVisible={5}
/>

🚀 What You Can Build

Real-world applications powered by AgentStack:

📈 Financial Analysis Platform

// Supervisor network coordinates specialized agents
const report = await financialIntelligenceNetwork.execute({
    symbol: 'TSLA',
    includeTechnicalAnalysis: true,
    includeNewsSentiment: true,
    generateCharts: true,
})
// → Supervisor network delegates to: researchAgent → stockAnalysisAgent → chartGeneratorAgent → reportAgent
// → Generates PDF report with charts and citations

Features:

• Real-time market data from multiple providers
• Automated technical analysis (RSI, MACD, Bollinger Bands)
• News sentiment analysis with SerpAPI
• Interactive chart generation
• PDF report export with source citations

📚 Enterprise Knowledge Base

// Ingest and query company documents
await documentProcessingWorkflow.execute({
    source: 'https://company.com/docs',
    includeSubpages: true,
    chunkingStrategy: 'semantic',
    extractMetadata: true,
})

const answer = await knowledgeBaseAgent.execute({
    query: 'What is our refund policy?',
    includeSources: true,
    confidenceThreshold: 0.8,
})
// → Searches across all indexed documents
// → Returns answer with source URLs

Features:

• Web scraping with recursive crawling
• PDF/CSV/JSON document processing
• Semantic chunking with 10 strategies
• Hybrid search (vector + keyword)
• Source attribution for every answer

🤖 AI Coding Assistant

// Supervisor network coordinates coding team
const result = await codingTeamNetwork.execute({
    task: 'Refactor authentication module',
    code: './src/auth/*',
    requirements: [
        'Improve security',
        'Add rate limiting',
        'Better error handling',
    ],
})
// → Supervisor network delegates: codeArchitectAgent → codeReviewerAgent → testEngineerAgent → refactoringAgent
// → Each agent handles specific aspect using delegation hooks

Features:

• Multi-agent code review pipeline
• Automatic test generation
• Security vulnerability detection
• TypeScript/React expertise
• GitHub integration for PR automation

📊 Content Creation Studio

// Supervisor network orchestrates content pipeline
const content = await contentCreationNetwork.execute({
    topic: 'Sustainable investing trends',
    formats: ['blog', 'social', 'newsletter'],
    tone: 'professional',
    seoOptimize: true,
})
// → Supervisor network delegates: copywriterAgent → editorAgent → contentStrategistAgent → seoAgent
// → Each agent specializes in different aspect of content creation

Features:

• Multi-format content generation
• SEO optimization with keyword research
• Tone and style consistency
• Social media post generation
• Editorial calendar integration

🔍 Research Synthesis Engine

// Supervisor network coordinates research pipeline
const research = await researchPipelineNe