2FastLabs/agent-squad

Agent Squad is a multi-agent orchestration framework for Python, TypeScript, and Swift that routes user queries to specialized AI agents using configurable classifiers. It supports diverse LLM providers including Amazon Bedrock, Anthropic, and OpenAI, while enabling tool integration via the Model Context Protocol (MCP) and retrieval-augmented generation through knowledge bases. The system manages conversation history with persistent storage and automatic summarization, and includes built-in patterns for supervisor coordination and anti-hallucination grounding.

47 changes.

The project rebranded and restructured its core library from 'multi-agent-orchestrator' to 'agent-squad', introducing a modular architecture with dedicated agent, classifier, and storage implementations across TypeScript and Python SDKs. This period focused on establishing a robust public API, adding comprehensive unit tests, and integrating new capabilities like the Model Context Protocol (MCP) and SQL storage backends. Extensive example applications were developed to demonstrate the new framework's streaming, tool integration, and multi-agent orchestration features.

27 changes.

This period focused on building out the AgentSquad framework across Python, TypeScript, and Swift, introducing core components like classifiers, retrievers, and grounded agent patterns. Significant effort was dedicated to integrating Model Context Protocol (MCP) servers for dynamic tool discovery and enabling native UI widget support in Swift examples. The work also included implementing voice interaction capabilities and modular storage systems with history summarization.

Introduces a new Streamlit-based demo application that orchestrates AI agents to generate movie concepts. The app allows users to input a movie idea, genre, target audience, and runtime, then coordinates a ScriptWriter agent to create a script outline and a CastingDirector agent (using a web search tool) to suggest actors, with a Supervisor agent managing the workflow and providing a final overview.

examples/python/movie-production · high confidence

This change introduces a new Streamlit-based demo application for AI-powered travel planning. The app allows users to input a destination and travel duration to generate a personalized, day-by-day itinerary. It leverages the AgentSquad framework, coordinating a ResearcherAgent (which uses DuckDuckGo web search via a custom tool) and a PlannerAgent, managed by a SupervisorAgent to produce the final plan using Amazon Bedrock.

examples/python/travel-planner · high confidence

Added Python and TypeScript examples in the \examples/bedrock-flows\ directory demonstrating how to use the \BedrockFlowsAgent\ for direct, single-agent invocation. The examples show how to configure the agent with a specific flow identifier and alias, implement custom input/output encoders to handle conversation history, and integrate the agent into the \AgentSquad\ orchestrator for interactive sessions.

examples/bedrock-flows · high confidence

The retrievers module now includes two new concrete implementations: \DakeraRetriever\, which queries a self-hosted Dakera memory server using the \dakera\ Python client, and \AmazonKnowledgeBasesRetriever\, which integrates with AWS Bedrock Agent Runtime. Both classes extend the new \Retriever\ abstract base class, which defines the standard interface (\retrieve\, \retrieve\_and\_combine\_results\, \retrieve\_and\_generate\) for all retriever plugins in the system.

_python/src/agent\squad/retrievers · high confidence

Added a new example in the \examples/fast-api-streaming\ directory that demonstrates a FastAPI web service integrating with the Agent Squad framework. The example provides a \/stream\_chat/\ endpoint that accepts user queries and returns real-time streaming responses using AWS Bedrock, featuring a Tech agent and a Health agent configured within the orchestrator.

examples/fast-api-streaming · high confidence

Added a new example in the \examples/grounded-agent-chatbot\ directory demonstrating a two-LLM anti-hallucination pattern using the \GroundedAgent\ framework. The Python chatbot separates responsibilities into a 'gatherer' agent that calls tools to retrieve product data and a 'presenter' agent that formats the response using only that curated data, ensuring prices and stock status are never invented. The example includes a minimal console interface and an in-memory product catalog for testing.

examples/grounded-agent-chatbot · high confidence

Introduced a new \DakeraRetriever\ component in the Swift SDK that enables agents to ground their responses on a self-hosted Dakera memory server. This addition provides both a direct \retrieve(\_:)\ API for manual RAG and a \search\_memory\ tool integration for use with \Agent\ or \GroundedAgent\ instances, allowing models to query stored documents via natural language. The implementation uses standard \URLSession\ for transport, requiring no new third-party dependencies, and supports configuration for namespaces, API keys, and metadata filtering.

swift/Sources/AgentSquad/Retrieval · high confidence

Introduces a new example in \examples/text-2-structured-output\ that demonstrates converting natural language queries into structured data using a multi-agent architecture. The sample includes a \ProductSearchAgent\ that parses user intent into JSON search parameters, a \Returns and Terms Assistant\ for policy inquiries, and a \Greeting Agent\ for navigation, all coordinated by an \AgentSquad\ orchestrator. The implementation uses AWS Bedrock with Claude 3 Sonnet, supports streaming responses via a custom callback handler, and provides a runnable Python script (\main.py\) with interactive CLI usage and detailed setup instructions.

examples/text-2-structured-output · high confidence

The common library now includes utilities to automatically append a custom user-agent string to AWS SDK v3 client requests. This feature injects a middleware that identifies the specific feature being used and the current library version (1.1.5), enabling usage tracking for the Mao for AWS Lambda project. The implementation includes type definitions for the AWS SDK client interface and a version constant, ensuring that the user-agent is added only once per client instance.

typescript/src/common · high confidence

Added a new example in the \examples/bedrock-prompt-routing\ directory demonstrating how to use Amazon Bedrock Prompt Routing with \BedrockClassifier\ and \BedrockLLMAgent\. The example includes a Python script (\main.py\) showing how to configure an \AgentSquad\ orchestrator with a classifier and agents that utilize prompt routing, along with a \readme.md\ file providing setup and usage instructions.

examples/bedrock-prompt-routing · high confidence

New demo scripts have been added to the examples/jev-demo directory for both Python and TypeScript. These demos showcase the JevClassifier's ability to route multi-turn conversations across four distinct domains (Tech Support, Billing, Travel, and Wellness) using real agent responses from Amazon Bedrock. The Python demos include jev\_classifier\_demo.py for scripted and interactive testing, and jev\_vs\_bedrock\_classifier\_demo.py for side-by-side comparison with the BedrockClassifier. The TypeScript equivalents are jevClassifierDemo.ts and jevVsBedrockClassifierDemo.ts, along with a new tsconfig.json for the TypeScript example directory. The demos highlight Jev's cost-effectiveness and accuracy in handling complex conversation histories with interleaved topics.

examples/jev-demo · high confidence

New sample code has been added to the \examples/bedrock-inline-agents\ directory for both Python (\python/main.py\) and TypeScript (\typescript/main.ts\). These examples demonstrate how to initialize and interact with the \BedrockInlineAgent\ class, including configuration of action groups (such as the Amazon Code Interpreter and custom Lambda-backed actions) and knowledge bases, as well as handling interactive user sessions.

examples/bedrock-inline-agents · high confidence

A new example script (examples/tools/python/weather\_tool\_example.py) demonstrates how to integrate a custom weather tool with both Bedrock and Anthropic agents. The example shows how to define tool schemas using the updated AgentTools/AgentTool classes, configure tool handlers for different LLM providers, and execute tool calls within a conversation context.

examples/tools · high confidence

A new home page has been added to the Streamlit application, providing an overview of the AWS Agent Squad framework demos. The page introduces two featured examples: the AI Movie Production Studio, which utilizes multiple Bedrock LLM agents for script and casting generation, and the AI Travel Planner, which employs Anthropic agents for destination research and itinerary planning.

examples/python/pages · high confidence

The \agent\_squad.shared\ package now includes \user\_agent.py\ and \version.py\, providing utilities to automatically append a feature-specific identifier (e.g., 'MAOPY/...') to the User-Agent header of AWS SDK (boto3/botocore) requests. This allows downstream services to identify requests originating from specific features or environments within the AWS ecosystem.

_python/src/agent\squad/shared · high confidence

The Python demo now includes a new weather tool example (weather\_tool.py) that demonstrates the updated AgentTool and AgentTools definitions. This example integrates with the Open-Meteo API to fetch current weather data based on latitude and longitude, and includes handlers for both Anthropic and Bedrock AI providers to process tool use responses.

examples/python-demo/tools · high confidence

The \examples/strands-agents-demo\ now includes an interactive multi-agent demo that features a new AWS Documentation Agent. This agent is configured with two Model Context Protocol (MCP) clients (\awslabs.aws-documentation-mcp-server\ and \awslabs.cost-analysis-mcp-server\), enabling it to utilize external tools for answering AWS service questions and performing cost calculations. The demo also retains existing agents for health, weather, and math tasks.

examples/strands-agents-demo · high confidence

This change introduces the Python implementation of the Agent Squad framework, a multi-agent orchestration system for Python 3.11+. The package provides an \AgentSquad\ orchestrator that routes requests to specialized agents (such as Bedrock, Anthropic, and OpenAI agents) using configurable classifiers. It includes support for streaming responses, conversation history storage (in-memory, DynamoDB, and SQL), and optional integrations for AWS, Anthropic, OpenAI, Strands, Dakera, and MCP tools via optional extras. The release also includes a \JevClassifier\ for typed, non-LLM routing decisions, along with comprehensive documentation, contribution guides, and CI/CD configuration using Ruff for linting and formatting.

python · high confidence

Added MCPToolProvider, a new tool provider that integrates one or more Model Context Protocol (MCP) servers into the agent system. It supports stdio, SSE, and streamable-http transports, dynamically loading the MCP SDK (v2 client preferred for protocol 2026-07-28, falling back to v1 SDK) to expose remote tools as local agent capabilities, including passthrough of UI templates and visibility metadata.

typescript/src/tools · high confidence

Adds a new Swift-based OpenAI Realtime voice runtime (\RealtimeRuntime\) that manages audio I/O, session lifecycle, and event routing. It supports two agent patterns: a single-LLM voice assistant (\OpenAIVoiceAssistant\) and a grounded two-phase assistant (\OpenAIGroundedVoiceAssistant\) that separates tool gathering from speech presentation. Key capabilities include barge-in handling with audio truncation, per-turn and session-level tracing (with configurable \tracePerTurn\ and \traceName\), reasoning effort escalation for tool calls, and transport loss error handling. The runtime is testable via protocol-based audio and transport seams.

swift/Sources/AgentSquad/Runtimes · high confidence

This change adds the Swift source files for the AgentSquad core library, establishing the foundational architecture for multi-agent orchestration. It introduces the \AgentProtocol\ for defining agent capabilities and \LLMClassifier\ for routing user inputs to the appropriate agent based on an LLM's selection. The framework includes a \ChatCompletionsClient\ for streaming interactions with various LLM providers (OpenAI, Azure, etc.), a \JSONValue\ type for handling tool arguments and results, and a \ToolOutputCurator\ system to format tool outputs for a 'grounded' presenter. Additionally, it provides \ChatStorage\ for persisting conversation history and \AggregateToolProvider\ for managing multiple tool sources.

swift/Sources/AgentSquad/Core · high confidence

This change adds a comprehensive set of new agent types to the Python SDK, including Amazon Bedrock agents (standard, inline, flows, LLM, and translator), Anthropic, OpenAI, Lambda, Lex Bot, Comprehend Filter, Chain, Strands, Supervisor, and Grounded agents. It also establishes the core agent base classes, data structures (such as AgentResponse and AgentStreamResponse with thinking support), and callback interfaces that these implementations rely on.

_python/src/agent\squad/agents · high confidence

The demo application now includes a new Support Simulator UI that allows users to interact with an AI support backend via two distinct modes: a real-time Chat interface and an Email interface. The Chat mode features a split-view layout for customer and support agents, auto-scrolling message history, and automatic input focus management. The Email mode provides a form with customizable sender addresses and pre-defined templates (e.g., order status, returns) for composing messages. The simulator handles AWS Amplify authentication, manages GraphQL subscriptions for real-time responses, and persists session state in local storage.

examples/ecommerce-support-simulator/resources/ui · high confidence

This change introduces a new demonstration application in the \examples/ecommerce-support-simulator\ directory that showcases multi-agent AI orchestration for customer service. The simulator features a React-based web interface (built with Astro) allowing users to interact via real-time chat or email-style communication. It deploys a production-ready AWS architecture using AWS CDK, including an AppSync GraphQL API, SQS queues for message routing, Lambda functions for agent processing, and Cognito for authentication. The system utilizes specialized AI agents (powered by Anthropic Claude models) to handle order management, product information retrieval, and human handoffs, supported by mock data for realistic scenario testing.

examples/ecommerce-support-simulator · high confidence

Added a new example application in \examples/chat-chainlit-app\ that demonstrates a Chainlit-based chat interface backed by the \agent\_squad\ orchestration framework. The app integrates three distinct agents: a technology agent and a travel agent using Amazon Bedrock (Anthropic Claude), and a health agent using a local Ollama model (Llama 3.1). It features a Bedrock-based classifier to route user queries to the appropriate agent and supports both streaming and non-streaming response handling for real-time chat interactions.

examples/chat-chainlit-app · high confidence

Users can now use the DakeraRetriever to fetch relevant documents from a self-hosted Dakera memory server for use as retrieval-augmented context. This new retriever extends the base Retriever class and uses the @dakera-ai/dakera SDK (loaded lazily as an optional peer dependency) to perform text queries against a specified namespace. It supports configuration via options or environment variables (DAKERA\_API\_KEY, DAKERA\_URL) and provides methods to retrieve results or combine them into a single string. The implementation also includes validation for required namespace and API key, and explicitly throws an error if the optional peer dependency is not installed.

typescript/src/retrievers · high confidence

The classifier module in \typescript/src/classifiers\ has been expanded with two new classification strategies: a \JevClassifier\ that uses the TypeSafe Jev System One API for structured choice decisions, and an \OpenAIClassifier\ that leverages OpenAI function calling to select agents. The core \Classifier\ base class has been refactored to include a \ClassifierCallbacks\ interface for lifecycle events (start/stop) and to remove the hardcoded \BedrockLLMAgent\ default fallback, meaning classification now returns \null\ if no agent matches rather than defaulting to a specific agent. Additionally, the \BedrockClassifier\ has been updated to conditionally apply \toolChoice\ only for Anthropic and Mistral models, and all classifiers have been migrated to the new \typescript/\ directory structure.

typescript/src/classifiers · high confidence

Added a new example in \examples/langfuse-demo\ that demonstrates a multi-agent system using AWS Bedrock with integrated observability via Langfuse. The demo includes a main application entry point (\main.py\) that orchestrates specialized agents (Tech, Health, Weather) and implements custom callback classes (\BedrockClassifierCallbacks\, \LLMAgentCallbacks\, \ToolsCallbacks\) to track classification decisions, agent interactions, and tool usage as Langfuse traces. It also provides a \weather\_tool.py\ implementation for fetching real-time weather data and a \README.md\ with setup instructions for running the interactive demo.

examples/langfuse-demo · high confidence

Added a runnable Python MCP server example (\examples/mcp-shop-server\) that demonstrates integrating Model Context Protocol tools with native SwiftUI UI widgets. The server exposes order-lookup tools (\get\_order\ and \app-only refresh\_order\) that return structured data and advertise a UI resource URI, allowing the ChatGPTStyleChat Swift sample to render native cards instead of web views. Built on the \mcp\ 2.x library (protocol version 2026-07-28) with fallback support for older clients, it serves over streamable HTTP and includes documentation for consumption via TypeScript and Python agent-squad clients.

examples/mcp-shop-server · high confidence

A new \MCPToolProvider\ class has been added to \agent\_squad.tools\, allowing agents to dynamically discover and use tools exposed by external Model Context Protocol (MCP) servers. Users can configure connections via stdio, Streamable HTTP, or legacy SSE transports using \MCPServerConfig\, and the provider automatically handles tool definition synchronization and UI metadata passthrough (such as visibility and resource URIs) to ensure the agent model sees the correct tools. This feature requires the optional \mcp\ extra package and supports both MCP SDK 1.x and 2.x versions through compatibility shims.

_python/src/agent\squad/tools · high confidence

The \python/src/agent\_squad\ package introduces three new capabilities: an \AgentOverlapAnalyzer\ that uses TF-IDF cosine similarity to detect description overlap and potential conflicts between agents; a \classifier\_test\_tool\ for evaluating routing accuracy, latency, and token usage against configurable test cases; and an \MCPToolProvider\ for integrating Model Context Protocol servers. The module also exposes a \user\_agent\ injection utility and conditionally exports MCP components when dependencies are available.

_python/src/agent\squad · high confidence

Users can now persist chat history to a SQL database (via @libsql/client) using the new SqlChatStorage implementation, which handles connection management and schema initialization. Additionally, the new SummarizingChatStorage wrapper enables automatic history compression: it keeps raw messages intact for analytics while serving a summarized, truncated view to agents to reduce context size, triggered by a configurable message threshold. The base ChatStorage.isConsecutiveMessage method is now public, and internal timestamp-removal logic was adjusted for TypeScript compatibility.

typescript/src/storage · high confidence

A new Streamlit application has been added to the Python examples to showcase the AWS Agent Squad framework. This app provides a unified interface for two distinct demos: an AI Movie Production assistant (using Amazon Bedrock and Claude models) and an AI Travel Planner (using Anthropic's Claude models). Users can now run the application via \streamlit run main-app.py\ to navigate between these collaborative agent scenarios, with setup instructions and prerequisites detailed in the included README.

examples/python · high confidence

A new runnable iOS sample app (ChatGPTStyleChat) demonstrates a chat interface that renders interactive, native SwiftUI widgets inline alongside text responses. The app uses a GroundedAgent with a 'Brain' and 'Presenter' to fetch order data via tools, and includes a toggle to switch between text-only and text-plus-widget modes. It features a native 'Order Card' widget with a 'Refresh' button that calls an app-only tool directly, bypassing the LLM, and supports swapping the in-app tool provider for a remote MCP server via a simple configuration change.

examples/swift · high confidence

The TypeScript source has been relocated to the \typescript/src\ directory, establishing a new public API surface via \index.ts\ that exports agents, classifiers, retrievers, storage backends, and the \AgentSquad\ orchestrator. The \AgentSquad\ class now exposes \AgentSquadConfig\ options, including \USE\_DEFAULT\_AGENT\_IF\_NONE\_IDENTIFIED\ (defaulting to true) to control fallback behavior when intent classification fails, and \MAX\_MESSAGE\_PAIRS\_PER\_AGENT\ (defaulting to 100) to limit conversation history retention per agent. Additionally, the \AgentOverlapAnalyzer\ was moved to this new location and updated to use a private variable for preprocessed descriptions.

typescript/src · high confidence

The \typescript/src/agents\ directory now includes a full suite of agent implementations: \AnthropicAgent\ for Claude models with tool and streaming support, \BedrockLLMAgent\ for Amazon Bedrock LLMs with guardrails and reasoning, \BedrockInlineAgent\ for dynamic inline agent creation, \BedrockFlowsAgent\ for AWS Bedrock Flows, \BedrockTranslatorAgent\ for translation tasks, \ChainAgent\ for sequential agent execution, \ComprehendFilterAgent\ for content safety filtering, \GroundedAgent\ for the 2-LLM anti-hallucination pattern, and \SupervisorAgent\ for team coordination. These are built on a new base \Agent\ class with standardized \AgentCallbacks\ for lifecycle events and \AgentOptions\ for configuration.

typescript/src/agents · high confidence

The Agent Squad module now includes a complete chat storage layer with three persistent and in-memory backends and two composable wrappers. On iOS 17+/macOS 14+, DeviceChatStorage provides on-device, restart-surviving history via SwiftData (with a self-healing store and user-bound scoping); FileChatStorage offers an iOS 16-compatible JSON-file fallback; and InMemoryChatStorage supports fresh or seeded single-conversation sessions. SummarizingChatStorage wraps any store to keep agent context small by compressing history via a configurable summarizer while preserving raw data for analytics. TransformingChatStorage wraps any store to run pre-save message transforms (e.g., PII scrubbing) before persistence, with reads returning the transformed form.

swift/Sources/AgentSquad/Storage · high confidence

The agent squad now includes four new classifier implementations that route user input to the appropriate agent. The Bedrock classifier uses AWS Bedrock's converse API with tool use, the Anthropic classifier leverages the Anthropic SDK with tool use, the OpenAI classifier uses the OpenAI SDK with function calling, and the Jev classifier integrates with the TypeSafe Jev System One API using a choice-based decision model. All classifiers support configurable inference parameters, callbacks for lifecycle events, and history management, with availability checks for optional dependencies (AWS, Anthropic, OpenAI) while Jev is always available.

_python/src/agent\squad/classifiers · high confidence

The storage layer has been restructured into a modular system supporting multiple backends: in-memory, DynamoDB, and SQL (SQLite/Turso). A new \SummarizingChatStorage\ wrapper automatically compresses long conversation histories by summarizing older messages, keeping the agent's context window small while preserving the full raw history for analytics and audit via \fetch\_all\_chats\. The DynamoDB implementation now registers a 'storage-ddb' feature in the user agent header.

_python/src/agent\squad/storage · high confidence

Added a new example demonstrating a supervisor-mode architecture where a lead agent (SupervisorAgent) orchestrates a team of specialized agents (Tech, Sales, Health, Travel, Airlines, Claim, and Weather). The example showcases advanced features including streaming responses, tool callbacks for monitoring tool execution, and the use of a custom weather tool that fetches data from the Open-Meteo API. It also illustrates configuration for different agent types (Bedrock LLM, Amazon Bedrock Agent, Lex Bot) and includes support for 'thinking' mode in the lead agent.

examples/supervisor-mode · high confidence

A new types file introduces constants for supported AI models (including specific Claude, Llama, and GPT versions) and defines the core data structures for the application's agent system. It establishes AgentTypes to distinguish between default knowledge agents and classifiers, specifies provider types for Bedrock and Anthropic, and defines the ConversationMessage interface which now explicitly supports an optional citations field to surface references from responses like Amazon Bedrock. Additionally, it includes types for streaming responses, participant roles, and template variables.

typescript/src/types · high confidence

The Python demo in examples/python-demo now includes a new main-stream.py file demonstrating full streaming capabilities for BedrockLLMAgent, including handling of thinking tokens and custom callbacks for agent and tool events. The main.py file has been updated to showcase tool integration using the weather\_tool, with examples of both Bedrock and Anthropic agent configurations, and includes custom input/output payload encoders/decoders for AWS Bedrock integration.

examples/python-demo · high confidence

This change introduces a new Swift module (\AgentSquadMCP\) that enables the AgentSquad platform to interact with Model Context Protocol (MCP) servers. It provides an \MCPToolProvider\ that acts as a bridge between the AgentSquad core and MCP servers, handling tool discovery, execution, and the injection of host-supplied arguments (like session IDs) while hiding them from the model's schema. The implementation includes an \SDKMCPClient\ that wraps the official MCP Swift SDK, supporting HTTP streaming, custom HTTP header passthrough for authentication, and pagination for tool lists. It also surfaces MCP Apps UI metadata, allowing the platform to fetch and render UI templates (HTML, Remote DOM, or URL) advertised by MCP tools, while keeping structured content and metadata separate from the model's context.

swift/Sources/AgentSquadMCP · high confidence

Adds the Swift source files for the AgentSquad library, introducing the \Agent\ struct for single-LLM tool-use conversations, the \GroundedAgent\ struct for a two-LLM pattern that separates fact-gathering from answer presentation to reduce hallucinations, and the \Orchestrator\ struct to manage multi-agent routing, chat history persistence, and tracing.

swift/Sources/AgentSquad, swift/Sources/AgentSquad/Agents · high confidence

The TypeScript utilities now support returning UI widgets from tools via the new \ToolResult\ and \UIPayload\ types, allowing agents to surface render-only components (like MCP App widgets) alongside text without polluting the model's context. Additionally, the \AgentToolCallbacks\ class provides hooks for tool lifecycle events (start, end, error), and the \AccumulatorTransform\ has been updated to forward UI chunks to consumers while keeping them out of the accumulated text answer. These changes are accompanied by a rename of \saveChat\ to \saveConversationExchange\ and updates to the logger to use the new \AgentSquadConfig\.

typescript/src/utils · high confidence

The main entry point file (src/index.ts) and the central orchestration logic (src/orchestrator.ts) have been deleted. This removes the public exports for all agent types (Bedrock, Lambda, Lex, OpenAI), classifiers, retrievers, storage implementations, and the MultiAgentOrchestrator class itself, effectively stripping the library of its primary interface for managing multi-agent conversations.

src · high confidence

The entire user interface for the chat demo application has been deleted, including the React entry point, application components (such as the chat page, global header, and navigation panel), API client logic, and build configuration files (Vite, TypeScript, PostCSS, Prettier). This removes the previous web-based frontend from the examples/chat-demo-app/user-interface location.

examples/chat-demo-app/user-interface · high confidence

The chat demo application's user interface has been completely rewritten using the Astro framework with React and Tailwind CSS integrations. This new UI introduces rich Markdown rendering for chat responses, including syntax-highlighted code blocks, and adds a loading screen to improve perceived performance during API calls. Authentication is now handled via AWS Amplify, and the chat client has been refactored to support streaming responses. Additionally, the interface now automatically converts text-based emoticons (like :) or :D) into emojis within messages.

examples/chat-demo-app/ui · high confidence

The chat demo app replaces the previous Amazon Bedrock Agent construct with a new custom CDK construct (BedrockKnowledgeBase) that provisions an OpenSearch Serverless vector store and handles data source synchronization via custom Lambda resources. The Tech Agent now uses the Cohere Multilingual embedding model and indexes the Agent Squad framework documentation (TypeScript, Python, and docs content) instead of restaurant menu data. The stack also migrates the Lambda runtime to Node.js 20, moves the UI source to a ui directory, and removes the standalone Amazon Bedrock Agent feature flag.

examples/chat-demo-app · high confidence

The \AgentSquadAudio\ module now provides Swift classes (\MicCapture\, \AudioPlayback\, and \VoiceProcessedAudioIO\) that enable real-time voice interaction. By default, microphone capture uses Apple's Voice-Processing I/O for hardware echo cancellation, noise suppression, and automatic gain control, ensuring the assistant's voice is excluded from the input reference. The system supports instant barge-in via a \flush\ mechanism that cuts playback and sends a \conversation.item.truncate\ signal, while a \PlaybackClock\ accurately tracks played milliseconds to inform the session when audio was interrupted.

swift/Sources/AgentSquadAudio · high confidence

The CDK entry point now instantiates a separate UserInterfaceStack alongside the existing ChatDemoStack. This new stack deploys the user interface components in the us-east-1 region and explicitly connects to the chat backend by passing the multiAgentLambdaFunctionUrl from the ChatDemoStack, establishing a clear separation between the chat logic and the UI layer.

examples/chat-demo-app/bin · high confidence

The local demo has been refactored to import from the 'agent-squad' npm module instead of local source files, switching the orchestrator type to AgentSquad. A new Weather Agent has been added that utilizes a specific weather tool and handler, and the conversation runner now supports streaming output, including the display of 'thinking' content in cyan color when present in the response chunks.

examples/local-demo · high confidence

The chat demo application's backend logic has been migrated from the @aws/multi-agent-orchestrator library to the agent-squad framework. This change updates the orchestrator initialization to use AgentSquad and BedrockClassifier, replaces the previous agent registration pattern with explicit agent instantiation and system prompt configuration, and updates all tool handlers (weather, math) to return messages instead of mutating the conversation array. The demo also includes updated prompts for weather, health, tech, and math agents, and renames the 'find-my-name' response from 'Multi-agent orchestrator' to 'Agent Squad'.

examples/chat-demo-app/lambda · high confidence

The monolithic agent implementation in \src/agents/agent.ts\ and the specific \BedrockLLMAgent\ class have been removed. This change reflects the separation of agent definitions into their respective classes, restructuring the codebase to support a more modular agent architecture within the \src/agents\ directory.

src/agents · medium confidence

The file src/types/index.ts has been deleted, removing the centralized export of model ID constants (such as Bedrock and OpenAI identifiers), type definitions (including AgentTypes, ClassifierResult, and OrchestratorConfig), and the default configuration object. This change consolidates the type system by moving these definitions into their respective classes or modules, as indicated by the commit message 'seperated definitions into respective classes'.

src/types · high confidence

The \mathToolHanlder\ and \weatherToolHanlder\ in the local demo tools have been refactored to return the resulting conversation message directly rather than appending it to the input \conversation\ array. This change, along with stricter TypeScript typing and updated imports from the \agent-squad\ package, shifts the responsibility of managing conversation history from the individual tool implementations to the caller, ensuring a more predictable and functional flow for tool execution.

examples/local-demo/tools · high confidence

The TypeScript package directory now includes a dedicated README.md and SKILL.md to guide users and AI assistants on using the agent-squad framework, including details on the new JevClassifier and GroundedAgent. Additionally, the project configuration files (tsconfig.json, jest.config.js, .npmignore) have been moved into the typescript folder, and a new ESLint flat config (eslint.config.mjs) has been added to standardize code quality rules.

typescript · high confidence

Added Swift tests for AgentSquad MCP bridging and tool provider logic; Added smoke tests for AgentSquadAudio components; Added tests for AgentOverlapAnalyzer and AgentSquad orchestrator; Added tests for AgentOverlapAnalyzer, AccumulatorTransform, and AgentTools; Added tests for DakeraRetriever and reorganized retriever test suite; Added tests for SummarizingChatStorage and reorganized storage test suite; Added tests for chat storage implementations; Added tests for the Dakera retriever and base Retriever abstraction; Added unit tests for MCPToolProvider; Added unit tests for Orchestrator and MCPToolProvider; Added unit tests for Python agent implementations; Added unit tests for classifier implementations; Added unit tests for the Swift AgentSquad library; Added unit tests for the classifier test tool; Added unit tests for utility helpers, logging, and agent tools; Removed Classifier and Orchestrator test files.

The core TypeScript package has been renamed from 'multi-agent-orchestrator' to 'agent-squad' (version 1.1.5), introducing support for the Model Context Protocol (MCP) via optional peer dependencies on @modelcontextprotocol/client and sdk, and adding new dependencies like @libsql/client and @aws-sdk/client-comprehend. A new Swift implementation (AgentSquad) is introduced via a Package.swift manifest, providing libraries for core agent logic, MCP integration, and audio processing. Additionally, the chat demo application's user interface has been migrated from a Vite/React setup to Astro, and several example applications (such as the ecommerce simulator and JEV demo) have been added or updated with their respective dependency manifests.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 45 → 64 (+18.4)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 78 → 80 (+2.1)
• Architecture 88 → 99 (+11.1)
• Maturity 51 → 65 (+13.7)
• Readiness 31 → 58 (+26.7)
• Security 52 → 60 (+8.3)
• Domain Modelling 100 (new)

• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (typescript/package-lock.json)
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (python/src/agent_squad/tools/mcp_tool_provider.py)
• Duplicated block (13 lines × 2) (python/src/agent_squad/agents/anthropic_agent.py)
• Duplicated block (15 lines × 2) (python/src/tests/agents/test_bedrock_inline_agent.py)
• Duplicated block (18 lines × 2) (python/src/agent_squad/agents/bedrock_llm_agent.py)
• Duplicated block (8 lines × 2) (python/src/agent_squad/agents/amazon_bedrock_agent.py)
• High CVE: [GHSA redacted] (typescript/package-lock.json)
• High CVE: [GHSA redacted] (typescript/package-lock.json)
• High CVE: [GHSA redacted] (typescript/package-lock.json)
• High CVE: [GHSA redacted] (typescript/package-lock.json)
• High CVE: [GHSA redacted] (typescript/package-lock.json)
• High CVE: [GHSA redacted] (typescript/package-lock.json)
• High CVE: [GHSA redacted] (typescript/package-lock.json)
• High CVE: [GHSA redacted] (typescript/package-lock.json)
• High CVE: [GHSA redacted] (typescript/package-lock.json)
• High CVE: [GHSA redacted] (typescript/package-lock.json)
• High CVE: [GHSA redacted] (typescript/package-lock.json)
• High CVE: [GHSA redacted] (typescript/package-lock.json)
• …and 57 more

• AgentOverlapAnalyzer.analyze_overlap (cognitive 25) (python/src/agent_squad/agent_overlap_analyzer.py)
• AgentSquad.dispatchToAgent (cognitive 26) (typescript/src/orchestrator.ts)
• AgentTools.tool_handler (cognitive 18) (python/src/agent_squad/utils/tool.py)
• AmazonBedrockAgent.processRequest (cognitive 22) (typescript/src/agents/amazonBedrockAgent.ts)
• AmazonBedrockAgent.process_request (cognitive 18) (python/src/agent_squad/agents/amazon_bedrock_agent.py)
• AnthropicAgent.handleStreamingResponse (cognitive 34) (typescript/src/agents/anthropicAgent.ts)
• AnthropicAgent.handleStreamingResponse (cyclomatic 22) (typescript/src/agents/anthropicAgent.ts)
• AnthropicAgent.processRequest (cognitive 20) (typescript/src/agents/anthropicAgent.ts)
• AnthropicAgent.processRequest (cyclomatic 16) (typescript/src/agents/anthropicAgent.ts)
• BedrockClassifier.processRequest (cognitive 18) (typescript/src/classifiers/bedrockClassifier.ts)
• BedrockClassifier.process_request (cognitive 19) (python/src/agent_squad/classifiers/bedrock_classifier.py)
• BedrockInlineAgent.inlineAgentToolHandler (cognitive 40) (typescript/src/agents/bedrockInlineAgent.ts)
• BedrockInlineAgent.inlineAgentToolHandler (cyclomatic 17) (typescript/src/agents/bedrockInlineAgent.ts)
• BedrockInlineAgent.inline_agent_tool_handler (cognitive 51) (python/src/agent_squad/agents/bedrock_inline_agent.py)
• BedrockInlineAgent.inline_agent_tool_handler (cyclomatic 16) (python/src/agent_squad/agents/bedrock_inline_agent.py)
• BedrockLLMAgent.handleStreamingResponse (cognitive 22) (typescript/src/agents/bedrockLLMAgent.ts)
• BedrockLLMAgent.handleStreamingResponse (cyclomatic 18) (typescript/src/agents/bedrockLLMAgent.ts)
• BedrockLLMAgent.handle_single_response (cognitive 17) (python/src/agent_squad/agents/bedrock_llm_agent.py)
• BedrockLLMAgent.handle_streaming_response (cognitive 33) (python/src/agent_squad/agents/bedrock_llm_agent.py)
• BedrockLLMAgent.handle_streaming_response (cyclomatic 27) (python/src/agent_squad/agents/bedrock_llm_agent.py)
• …and 127 more

• 13 commits — 11 feature/other, 2 fixes

• (repo) — 4 commits
• examples/jev-demo — 3 commits
• python/src — 3 commits
• docs/package-lock.json — 1 commit
• python/README.md — 1 commit
• python/setup.cfg — 1 commit

• fix: Merge pull request #698 from 2FastLabs/fix/python-bedrock-current-models
• fix: fix(python): make Bedrock classifier and agents work with current Claude models
• change: Merge pull request #699 from 2FastLabs/feat/jev-classifier
• change: Merge pull request #701 from 2FastLabs/chore/release-py-1.1.4-ts-1.1.5
• change: Merge pull request #702 from 2FastLabs/docs/jev-package-readmes
• change: chore: bump versions — Python 1.1.4, TypeScript 1.1.5
• change: chore: drop unrelated lockfile and docs dependency changes
• change: docs: mention JevClassifier in the Python and TypeScript package READMEs
• change: fixing bedrock params
• change: support for jev classifier
• change: test example in python using jev
• change: updated code
• change: updated demos

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

2FastLabs/agent-squad was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.