Registry Driven Agent Composition With Hierarchical Delegation

via “nested conversations and hierarchical agent composition”

Microsoft's multi-agent framework — event-driven, typed messages, group chat, AutoGen Studio.

Unique: Enables nested conversations through the Agent protocol's support for message composition and the runtime's ability to spawn child conversations with inherited context. Unlike flat agent teams, nested conversations allow agents to reason about delegation and maintain parent-child relationships, enabling true hierarchical problem decomposition.

vs others: More structured than LangGraph's subgraph approach because conversation boundaries are explicit and context is managed through message types; more flexible than CrewAI's hierarchical teams because nesting is dynamic and agents can decide when to delegate.

via “sequential and hierarchical crew orchestration with task delegation”

Multi-agent orchestration — role-playing agents with tasks, processes, tools, memory, and delegation.

Unique: Implements dual-mode orchestration (sequential + hierarchical) with explicit A2A protocol for delegation, allowing both linear pipelines and manager-worker hierarchies in the same framework without requiring separate abstractions

vs others: More structured than LangGraph's state machine approach (explicit task/agent binding), but less flexible for complex conditional routing; simpler than AutoGen's nested group chats for basic hierarchies

via “multi-agent orchestration with hierarchical agent types”

Google's agent framework — tool use, multi-agent orchestration, Google service integrations.

Unique: Implements three distinct agent execution patterns (Loop, Sequential, Parallel) as first-class types with explicit state hierarchy and context propagation, rather than generic agent composition. Each pattern has dedicated configuration classes (LoopAgentConfig, SequentialAgentConfig, ParallelAgentConfig) that enforce pattern-specific semantics and prevent misuse.

vs others: More structured than LangGraph's flexible graph approach — enforces specific execution semantics upfront, reducing debugging complexity for common multi-agent patterns at the cost of less flexibility for custom topologies

via “multi-agent orchestration via message-passing architecture”

Python framework for multi-agent LLM applications.

Unique: Uses a two-level Agent-Task abstraction where Tasks manage message routing and delegation while Agents encapsulate LLM state and tools independently, enabling loose coupling and composability that single-agent frameworks lack. The ChatDocument message protocol provides structured communication semantics across agent boundaries.

vs others: Provides cleaner agent composition than LangChain's agent executor (which uses function-call callbacks) and more explicit delegation control than AutoGen (which relies on conversation-based agent discovery).

via “recursive subagent delegation with task parallelization”

An open-source long-horizon SuperAgent harness that researches, codes, and creates. With the help of sandboxes, memories, tools, skill, subagents and message gateway, it handles different levels of tasks that could take minutes to hours.

Unique: Implements true recursive delegation where subagents can spawn further subagents with inherited context, rather than flat agent pools. Uses thread-local state to track parent-child relationships and enable context scoping, allowing each subagent to operate as if it were the lead agent within its domain.

vs others: More expressive than pool-based agent systems (like multi-agent frameworks with fixed agent counts) because task structure can dynamically determine agent hierarchy, enabling natural decomposition of complex problems.

via “subagent delegation with hierarchical task decomposition”

The agent that grows with you

Unique: Enables hierarchical subagent spawning with independent toolsets, model configurations, and memory contexts, allowing complex tasks to be decomposed into specialized subtasks handled by purpose-built agents

vs others: More flexible than LangChain's agent tools because subagents are full agent instances with independent configurations, not just tool invocations, enabling true hierarchical reasoning

via “agent skills and sub-agent delegation with hierarchical task decomposition”

An open-source AI agent that brings the power of Gemini directly into your terminal.

Unique: Implements a skill registry system that allows pre-configured agents to be invoked as tools, enabling hierarchical task decomposition. Each skill is a complete agent configuration with its own instructions, tools, and model settings.

vs others: More modular than monolithic agents because skills can be developed, tested, and reused independently, enabling teams to build complex agent systems from composable components.

via “hierarchical sub-agent delegation with task decomposition”

Agent harness built with LangChain and LangGraph. Equipped with a planning tool, a filesystem backend, and the ability to spawn subagents - well-equipped to handle complex agentic tasks.

Unique: Sub-agents are full LangGraph compiled graphs invoked as nodes in parent's graph, enabling true isolation and streaming support rather than simple function calls. Allows sub-agents to have their own planning loops, tool access, and memory while remaining coordinated by parent.

vs others: More robust than sequential tool calling because sub-agents can reason independently and make their own tool decisions, whereas a single agent trying to handle all subtasks may lose focus or make suboptimal tool choices.

via “agent registry and multi-agent orchestration”

The Frontend Stack for Agents & Generative UI. React + Angular. Makers of the AG-UI Protocol

Unique: Implements agent registry as a runtime service that manages agent lifecycle and routing. Enables multiple agents to coexist in the same runtime with isolated state and tool execution contexts, supporting agent composition and delegation patterns.

vs others: More structured than ad-hoc agent selection; AgentRegistry provides centralized agent management and isolation. Enables agent composition patterns (one agent delegating to another) without custom orchestration code.

via “multi-tier agent registry with specialization-based delegation”

Teams-first Multi-agent orchestration for Claude Code

Unique: Implements a tiered agent system with explicit specialization profiles and hook-driven delegation matching, allowing agents to be customized independently while maintaining centralized routing logic through pre-processing hooks that analyze task characteristics against agent metadata

vs others: More structured than generic function-calling approaches because it uses explicit agent tiers and specialization categories, enabling better task-to-agent matching than systems that treat all agents as interchangeable

via “hierarchical task decomposition with subagent spawning”

Your agent in your terminal, equipped with local tools: writes code, uses the terminal, browses the web. Make your own persistent autonomous agent on top!

Unique: Enables agents to spawn child agents with inherited configuration and tools, creating a hierarchical execution model where subtasks are isolated in separate agent instances with their own conversation loops

vs others: More flexible than simple function decomposition because subagents can use the full tool set and reasoning capabilities, but more expensive than sequential tool calls because each subagent makes independent LLM calls

via “multi-agent swarm orchestration with role-based task delegation”

Workspace template + MCP server for Claude Code, Codex CLI, Cursor & Windsurf. Multi-agent knowledge engine (ag-refresh / ag-ask) that turns any codebase into a queryable AI assistant.

Unique: Uses a declarative AGENTS.md manifest to define agent roles, capabilities, and delegation rules, enabling task routing without code changes. Agents maintain separate memory and tool sets while sharing a common knowledge hub, enabling specialization without isolation. The framework provides explicit inter-agent communication patterns rather than requiring agents to coordinate through shared state.

vs others: Unlike LangChain's agent teams (which require code-based agent definitions) or AutoGen (which uses a message-passing architecture), Antigravity's multi-agent system uses declarative role definitions in AGENTS.md, making it easier to modify agent responsibilities without code changes. The shared knowledge hub approach is more efficient than message-passing for large agent swarms.

via “registry-driven agent composition with hierarchical delegation”

AI agent framework for plan-first development workflows with approval-based execution. Multi-language support (TypeScript, Python, Go, Rust) with automatic testing, code review, and validation built for OpenCode

Unique: Uses a declarative registry.json as the single source of truth for agent definitions, enabling agents to be discovered and composed dynamically at runtime rather than through hardcoded imports. The hierarchical delegation pattern (primary agents → subagents) is explicitly modeled in the registry with typed component categories (Agents, Subagents, Contexts, Commands), allowing the framework to enforce composition rules and validate agent relationships during installation.

vs others: More maintainable than agent frameworks that require code changes to add new agents, and more flexible than monolithic agent designs because agents can be versioned, swapped, and composed independently through registry metadata rather than tight coupling.

via “subagent routing and agent definition management”

Use your Claude Max subscription with OpenCode, Pi, Droid, Aider, Crush, Cline. Proxy that bridges Anthropic's official SDK to enable Claude Max in third-party tools.

Unique: Implements subagent routing with agent definition management, allowing parent agents to delegate to specialized subagents with session isolation and result aggregation.

vs others: Unlike flat agent architectures, Meridian's subagent routing enables hierarchical multi-agent systems where agents can delegate tasks without knowing about each other's implementation.

via “nested agent hierarchies and agent composition”

Multi-agent framework with diversity of agents

Unique: Implements agent composition through a delegation pattern where parent agents can spawn or coordinate sub-agents, with automatic message routing and result aggregation. Supports both sequential and parallel sub-agent execution with configurable synchronization and error handling.

vs others: More structured than flat multi-agent systems because it enables clear task hierarchies and specialization, and more flexible than rigid workflow engines because agent hierarchies can be defined dynamically based on task requirements

via “hierarchical agent delegation and sub-crew composition”

Framework for orchestrating role-playing agents

Unique: Allows agents to dynamically spawn sub-crews for task delegation, creating runtime-configurable hierarchies rather than static agent graphs, enabling adaptive task decomposition based on agent reasoning

vs others: More flexible than static agent graphs (like LangChain's AgentExecutor) because delegation is dynamic and can be determined by agent reasoning rather than pre-defined at configuration time

via “agent composition and hierarchical task decomposition”

We’ve been working with automating coding agents in sandboxes as of late. It’s bewildering how poorly standardized and difficult to use each agent varies between each other.We open-sourced the Sandbox Agent SDK based on tools we built internally to solve 3 problems:1. Universal agent API: interact w

Unique: Provides first-class support for agent composition with automatic state passing, error handling, and result aggregation, enabling hierarchical agents without manual orchestration logic

vs others: More integrated than manual agent orchestration because it handles state passing, error handling, and result aggregation automatically, reducing boilerplate compared to building composition logic manually

via “agent composition and hierarchical task decomposition”

AI agent orchestration framework for TypeScript/Node.js - 29 adapters (LangChain, AutoGen, CrewAI, OpenAI Assistants, LlamaIndex, Semantic Kernel, Haystack, DSPy, Agno, MCP, OpenClaw, A2A, Codex, MiniMax, NemoClaw, APS, Copilot, LangGraph, Anthropic Compu

Unique: Provides framework-agnostic agent composition with automatic dependency resolution and parallel execution, allowing agents from different frameworks to be composed into hierarchies

vs others: Supports cross-framework agent composition (LangChain agents with CrewAI agents) unlike framework-specific composition; automatic dependency resolution reduces manual orchestration code

via “hierarchical agentic rag with multi-level agent organization”

Agentic-RAG explores advanced Retrieval-Augmented Generation systems enhanced with AI LLM agents.

Unique: Organizes agents in explicit hierarchical structures with clear parent-child relationships and delegation protocols, rather than flat multi-agent systems, enabling scalable organization of complex reasoning with clear responsibility boundaries.

vs others: Scales better than flat multi-agent systems by organizing agents hierarchically, and provides clearer responsibility assignment than peer-to-peer agent networks by establishing explicit authority relationships.

via “agent composition and nested agent orchestration”

Hi HN,Over Thanksgiving weekend I wanted to build an AI agent. As a design exercise, I wrote it as a set of React components. The component model made it easier to reason about the moving parts, composability was straightforward (e.g., reusing agents/tools), and hooks/state felt like a rea

Unique: Treats agents as React components that can be nested and composed like any other component, enabling agent hierarchies to be expressed as component trees with natural prop and context flow

vs others: More natural composition than external agent orchestration frameworks because agent composition is just React component composition, leveraging existing React patterns and tooling