mdcontext 0.0.1 → 0.2.0

package/research/task-management-2026/02-agent-framework-patterns.md

@@ -0,0 +1,476 @@
+# AI Agent Framework Patterns for Task Management (2026)
+
+Research conducted: January 2026
+
+## Executive Summary
+
+The AI agent landscape has matured significantly, with 86% of copilot spending ($7.2B) now going to agent-based systems. Gartner predicts 40% of enterprise applications will feature task-specific AI agents by end of 2026, up from <5% in 2025. This document examines how leading frameworks handle task management, intent capture, and work coordination.
+
+---
+
+## Framework Approaches
+
+### LangChain / LangGraph
+
+**Architecture**: Graph-based workflow orchestration with checkpointing
+
+**Task Persistence**:
+
+- **Short-term memory**: Managed via checkpointers that save state at every "superstep"
+- **Long-term memory**: Integration with vector stores (Pinecone, Weaviate, Chroma) and databases (MongoDB, PostgreSQL)
+- **Thread-based isolation**: Each conversation/task gets a unique `thread_id` for multi-tenant scenarios
+
+**Key Features**:
+
+- `InMemorySaver` for experimentation
+- `SqliteSaver` for local workflows
+- `PostgresSaver` for production (used in LangSmith)
+- Fault tolerance: Failed nodes don't require re-running successful siblings
+- "Time travel" capability to roll back and replay execution states
+
+**LangMem SDK**: Dedicated long-term memory layer with episodic, semantic, and procedural memory types.
+
+Sources: [LangChain Docs](https://docs.langchain.com/oss/python/langchain/short-term-memory), [MongoDB Blog](https://www.mongodb.com/company/blog/product-release-announcements/powering-long-term-memory-for-agents-langgraph), [LangGraph](https://www.langchain.com/langgraph)
+
+---
+
+### CrewAI
+
+**Architecture**: Role-based multi-agent coordination inspired by human organizational structures
+
+**Task Persistence**:
+
+- **Short-term memory**: ChromaDB vector store
+- **Task results**: SQLite for recent task outcomes
+- **Long-term memory**: Separate SQLite table indexed by task description
+- **Entity memory**: Vector embeddings for recognizing entities across sessions
+
+**Coordination Model**:
+
+- Sequential, parallel, and conditional task execution
+- Hierarchical coordination with manager agents
+- Senior agents can override juniors and redistribute resources
+- Automatic planning flag generates step-by-step workflows before execution
+
+**Observability**:
+
+- Crew Control Plane for real-time tracing
+- Metrics, logs, and traces unified in dashboard
+- Project Manager Agent pattern for dependency resolution and milestone tracking
+
+Sources: [CrewAI](https://www.crewai.com/), [CrewAI Docs](https://docs.crewai.com/en/concepts/agents), [CrewAI Planning Guide](https://www.analyticsvidhya.com/blog/2025/12/crewai-planning/)
+
+---
+
+### AutoGPT
+
+**Architecture**: Autonomous goal decomposition with subtask management
+
+**Task Queue Management**:
+
+- Redis-based task queues for concurrent request handling
+- Custom dashboards for monitoring success rates and execution times
+- Automatic breakdown of high-level goals into subtasks
+
+**Memory**:
+
+- Short-term: In-session context
+- Long-term: Persistent storage for critical data
+- Task decomposition as core differentiator
+
+**Production Infrastructure** (2026):
+
+- Secure vault systems for 15+ API keys
+- Execution sandboxing with isolated environments
+- Comprehensive audit logging
+- Cost optimization: GPT-4 for planning, GPT-3.5-turbo for execution
+
+Sources: [AutoGPT Setup Guide](https://educatecomputer.com/how-to-setup-autogpt-for-local-computer-tasks/), [IBM on AutoGPT](https://www.ibm.com/think/topics/autogpt)
+
+---
+
+### OpenAI Agents SDK (successor to Swarm)
+
+**Architecture**: Lightweight, Python-first orchestration with handoffs
+
+**Key Concepts**:
+
+- **Routines**: Sets of instructions agents follow for specific actions
+- **Handoffs**: Seamless transitions between specialized agents
+- **Agent loop**: Built-in tool invocation cycle until task completion
+
+**Task Management Features**:
+
+- Function tools with automatic schema generation
+- Pydantic-powered validation
+- Sessions: Persistent memory layer within agent loops
+- Human-in-the-loop mechanisms
+- Horizontal and vertical multi-agent workflow support
+
+**State Management** (2025 updates):
+
+- Conversation state API for durable threads
+- Connectors and MCP servers for external context
+- Replayable state for debugging
+
+Sources: [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/), [OpenAI Swarm GitHub](https://github.com/openai/swarm), [VentureBeat on Swarm](https://venturebeat.com/ai/openais-swarm-ai-agent-framework-routines-and-handoffs)
+
+---
+
+### Microsoft AutoGen / Agent Framework
+
+**Architecture**: Asynchronous, event-driven multi-agent orchestration
+
+**Evolution**: AutoGen merged with Semantic Kernel into unified Microsoft Agent Framework
+
+**Orchestration Patterns**:
+
+- Sequential (GraphFlow for DAG-based execution)
+- Concurrent (parallel agent work)
+- GroupChat (conversational coordination)
+- Handoff (responsibility transfer as context evolves)
+- Magentic (manager agent with dynamic task ledger)
+
+**Memory Management**:
+
+- Multiple backends: in-memory, Redis, mem0
+- Chat history buffers
+- Summarization memory
+- Vector store integration for RAG
+- Sliding window memory options
+
+**Enterprise Features** (2025-2026):
+
+- Persistent state with error recovery
+- Context sharing across agents
+- Role-based access and auditability
+- Lifecycle management
+- Built-in observability for debugging at scale
+
+Sources: [Microsoft Agent Framework](https://learn.microsoft.com/en-us/agent-framework/overview/agent-framework-overview), [AutoGen Research](https://www.microsoft.com/en-us/research/project/autogen/), [Microsoft Foundry Blog](https://devblogs.microsoft.com/foundry/introducing-microsoft-agent-framework-the-open-source-engine-for-agentic-ai-apps/)
+
+---
+
+### Claude Code / Anthropic Patterns
+
+**Architecture**: File-system and shell-based persistence with subagent delegation
+
+**Task Persistence Mechanisms**:
+
+- **CLAUDE.md**: Persistent memory file for project context, preferences, and ongoing tasks
+- **Todo lists**: Markdown files preserved during context compaction
+- **Plans**: Markdown-based execution plans that persist across sessions
+- **Subagents**: Specialized instances with their own system prompts and conversation history
+
+**Key Patterns**:
+
+- Session-based organization grouping related tasks
+- Resource isolation preventing task interference
+- Circuit breaker patterns with exponential backoff
+- Resumable subagents retaining full conversation history
+
+**Philosophy**: Filesystem provides persistent context; shell provides execution primitives.
+
+Sources: [Claude Code Docs](https://code.claude.com/docs/en/sub-agents), [Apidog on Claude Background Tasks](https://apidog.com/blog/claude-code-background-tasks/), [Agent Design Patterns](https://rlancemartin.github.io/2026/01/09/agent_design/)
+
+---
+
+## Common Patterns Across Frameworks
+
+### 1. Hierarchical Memory Architecture
+
+All major frameworks implement layered memory:
+
+| Layer             | Purpose              | Typical Implementation           |
+| ----------------- | -------------------- | -------------------------------- |
+| Working Memory    | Current task state   | In-memory buffers                |
+| Episodic Memory   | Past interactions    | SQLite, conversation logs        |
+| Semantic Memory   | Learned knowledge    | Vector databases                 |
+| Procedural Memory | How to perform tasks | Embeddings, fine-tuned behaviors |
+
+### 2. Checkpointing for Fault Tolerance
+
+Every production framework now implements:
+
+- State snapshots at execution boundaries
+- Rollback capability for failed steps
+- Resume without re-running successful work
+- "Time travel" debugging
+
+### 3. Thread-Based Isolation
+
+Multi-tenant scenarios handled via:
+
+- Unique thread IDs per conversation/task
+- Separate checkpoint streams
+- Context isolation between users/sessions
+
+### 4. Intent Routing Pattern
+
+From Google's multi-agent design patterns:
+
+- Central dispatcher agent analyzes user intent
+- Routes to specialist agents (Billing, Tech Support, etc.)
+- Coordinator maintains context and synthesizes results
+
+### 5. Plan-and-Execute Architecture
+
+Cost optimization pattern gaining adoption:
+
+- Expensive model (GPT-4, Claude) creates strategy
+- Cheaper models (GPT-3.5, smaller LLMs) execute
+- Reported 90% cost reduction in some deployments
+
+---
+
+## File-Based vs Database vs API Approaches
+
+### File-Based (Claude Code, some local agents)
+
+**Pros**:
+
+- Simple, human-readable
+- Version control friendly
+- No infrastructure dependencies
+- Easy debugging and manual intervention
+
+**Cons**:
+
+- Limited querying capability
+- No concurrent access handling
+- Doesn't scale for enterprise
+
+**Best For**: Developer tools, single-user workflows, prototyping
+
+### Database-Backed (LangGraph, CrewAI, AutoGen)
+
+**Pros**:
+
+- ACID compliance
+- Concurrent access
+- Rich querying
+- Production-ready scaling
+
+**Cons**:
+
+- Infrastructure complexity
+- Requires ops expertise
+- Migration management
+
+**Common Choices**:
+
+- SQLite: Local/experimental
+- PostgreSQL: Production workloads
+- ChromaDB/Pinecone: Vector memory
+- Redis: Task queues, fast state
+
+**Best For**: Production multi-tenant systems, enterprise deployments
+
+### API-Based (Cloud services, managed platforms)
+
+**Pros**:
+
+- No infrastructure management
+- Built-in scaling
+- Cross-platform persistence
+
+**Cons**:
+
+- Vendor lock-in
+- Latency concerns
+- Cost at scale
+
+**Examples**: LangSmith, CrewAI Cloud, AWS AgentCore Memory
+
+---
+
+## Integration with Traditional Project Management
+
+### Jira Integration Patterns
+
+**Native (Atlassian Rovo)**:
+
+- AI workflows embedded in Jira
+- Custom workflow creation via natural language
+- Out-of-the-box Rovo Agents for task management
+
+**Third-Party Integrations**:
+
+- **Claude AI + Jira**: MCP-based connection for workflow automation
+- **Beam AI**: AI agents perform issue creation, status updates, data extraction
+- **CrewAI + Jira**: Automated project management via Gemini integration
+
+**Capabilities**:
+
+- Automated task assignment based on availability/expertise
+- Enhanced search across tickets and documentation
+- Automated responses to common queries
+- Data analysis for timeline and resource insights
+
+**Challenges**:
+
+- OAuth 2.0 setup complexity
+- Rate limits during high-traffic periods
+- Not plug-and-play; requires careful planning
+
+Sources: [Atlassian Rovo](https://www.atlassian.com/software/jira/ai), [Claude-Jira Integration](https://www.eesel.ai/blog/claude-ai-jira-integration), [Beam AI + Jira](https://beam.ai/integrations/jira)
+
+---
+
+## What's Working
+
+### Proven Success Patterns
+
+1. **Persistent Memory**: The "most destabilizing upgrade" - ability to carry state across time, tasks, and people
+2. **Bounded Workflows**: 68% of production agents use bounded rather than open-ended planning
+3. **Multi-Agent Specialization**: Breaking tasks across specialized agents enables parallelism and modular design
+4. **Human-in-the-Loop**: Critical for high-stakes decisions; built into all major frameworks
+5. **Checkpointing**: Essential for long-running workflows; enables pause/resume without context loss
+6. **Hierarchical Task Decomposition**: Planning agents delegate to execution agents
+
+### Production Metrics That Matter
+
+Organizations tracking three key metrics report 30% cost reductions and 35% productivity gains:
+
+- Time saved on manual tasks
+- Error reduction vs previous processes
+- Throughput increase in completed workflows
+
+---
+
+## What's Not Working
+
+### Common Failure Modes
+
+1. **Silent Failures**: Agents loop endlessly, skip steps, or give confident wrong answers without obvious errors
+2. **Data Pipeline Breaks**: Most prevalent cause of incorrect agent behavior in production
+3. **Scaling Gap**: ~65% experimenting with agents, <25% successfully scaled to production
+4. **Framework Abandonment**: 85% of in-depth case studies use custom implementations at scale
+5. **Open-Ended Planning**: Fails in production; bounded workflows required
+
+### Anti-Patterns
+
+- Treating agents as "productivity add-ons" rather than transformation drivers
+- Automating everything immediately instead of focusing on high-value processes
+- Neglecting observability and audit trails
+- Single all-purpose agents instead of specialized teams
+- Ignoring cost optimization (frontier models for everything)
+
+---
+
+## Emerging Best Practices
+
+### Architecture
+
+1. **Composable, Narrowly-Scoped Agents**: Easier to test, reason about, and evolve
+2. **Heterogeneous Model Architecture**: Expensive models for reasoning, cheap models for execution
+3. **Atomic Responsibilities**: Design agents around single, well-defined tasks
+4. **Standardized Interfaces**: MCP adoption for consistent agent-tool interaction
+
+### Monitoring & Reliability
+
+1. **Log Everything**: Prompts, responses, tool calls for replay and regression detection
+2. **Track Agent Behavior**: Accuracy, drift, context relevance, cost per agent
+3. **Reasoning Traces**: Capture decision rationale for accountability
+4. **CI/CD Integration**: Catch drift before production
+
+### Development Process
+
+1. **Structured Multi-Step Reasoning**: Chain-of-thought for complex workflows
+2. **Explicit Task Decomposition**: Don't rely on LLM to figure out structure
+3. **Feedback Loops**: Agents review and refine before final delivery
+4. **Document When Interfaces Stabilize**: Not before
+
+### Governance (Critical for 2026)
+
+1. **Real-Time Risk Management**: Not just ethical AI conversations
+2. **Compliance Integration**: Agents touch critical business processes
+3. **Audit Trails**: Every decision traceable
+4. **Protocol Adoption**: MCP under Linux Foundation governance
+
+---
+
+## Protocol Maturation: MCP, ACP, A2A
+
+The Model Context Protocol (MCP), IBM's Agent Communication Protocol (ACP), and Google's Agent-to-Agent (A2A) are consolidating under open governance:
+
+- **MCP**: Contributed to Linux Foundation's Agentic AI Foundation
+- **Composability Benefits**: Standardized interfaces enable agent specialization
+- **Testing Improvements**: Narrowly scoped agents easier to verify
+
+---
+
+## Key Takeaways
+
+1. **Memory is the differentiator**: Persistent context across sessions transforms agent capability
+2. **Database-backed persistence dominates**: SQLite/PostgreSQL for state, vector stores for semantic memory
+3. **Bounded workflows succeed**: Open-ended planning fails at scale
+4. **Specialization beats generalization**: Multi-agent teams outperform monolithic agents
+5. **Observability is mandatory**: You can't improve what you can't measure
+6. **2026 is the consolidation year**: Patterns moving from lab to production, standards maturing
+
+---
+
+## Framework Selection Guide
+
+| Use Case                   | Recommended Framework              |
+| -------------------------- | ---------------------------------- |
+| Rapid prototyping          | OpenAI Agents SDK                  |
+| Enterprise multi-agent     | Microsoft Agent Framework          |
+| Graph-based workflows      | LangGraph                          |
+| Role-based team simulation | CrewAI                             |
+| Developer tooling          | Claude Code patterns               |
+| Autonomous goal pursuit    | AutoGPT                            |
+| Custom at scale            | Build your own (85% of production) |
+
+---
+
+## References
+
+### LangChain/LangGraph
+
+- [Short-term Memory Docs](https://docs.langchain.com/oss/python/langchain/short-term-memory)
+- [MongoDB Long-Term Memory](https://www.mongodb.com/company/blog/product-release-announcements/powering-long-term-memory-for-agents-langgraph)
+- [LangGraph Persistence](https://docs.langchain.com/oss/python/langgraph/persistence)
+- [LangMem SDK Launch](https://www.blog.langchain.com/langmem-sdk-launch/)
+
+### CrewAI
+
+- [CrewAI Platform](https://www.crewai.com/)
+- [CrewAI GitHub](https://github.com/crewAIInc/crewAI)
+- [CrewAI Planning Guide](https://www.analyticsvidhya.com/blog/2025/12/crewai-planning/)
+
+### OpenAI
+
+- [Agents SDK](https://openai.github.io/openai-agents-python/)
+- [Swarm Framework](https://github.com/openai/swarm)
+- [Developer Updates 2025](https://developers.openai.com/blog/openai-for-developers-2025/)
+
+### Microsoft
+
+- [Agent Framework Overview](https://learn.microsoft.com/en-us/agent-framework/overview/agent-framework-overview)
+- [AutoGen Research](https://www.microsoft.com/en-us/research/project/autogen/)
+- [Foundry Updates](https://devblogs.microsoft.com/foundry/whats-new-in-microsoft-foundry-oct-nov-2025/)
+
+### Claude/Anthropic
+
+- [Claude Code Subagents](https://code.claude.com/docs/en/sub-agents)
+- [Agent Design Patterns](https://rlancemartin.github.io/2026/01/09/agent_design/)
+
+### Multi-Agent Patterns
+
+- [Google's Eight Patterns](https://www.infoq.com/news/2026/01/multi-agent-design-patterns/)
+- [Multi-Agent Systems 2026 Guide](https://dev.to/eira-wexford/how-to-build-multi-agent-systems-complete-2026-guide-1io6)
+- [Agent Orchestration 2026](https://iterathon.tech/blog/ai-agent-orchestration-frameworks-2026)
+
+### Best Practices & Trends
+
+- [Enterprise Implementation Guide](https://onereach.ai/blog/best-practices-for-ai-agent-implementations/)
+- [AI Agent Monitoring](https://uptimerobot.com/knowledge-hub/monitoring/ai-agent-monitoring-best-practices-tools-and-metrics/)
+- [Agentic AI Trends 2026](https://machinelearningmastery.com/7-agentic-ai-trends-to-watch-in-2026/)
+- [Production Agents Study](https://medium.com/generative-ai-revolution-ai-native-transformation/the-first-production-ai-agents-study-reveals-why-agentic-engineering-becomes-mandatory-in-2026-ec5e00514e5e)
+
+### Jira Integration
+
+- [Atlassian Rovo](https://www.atlassian.com/software/jira/ai)
+- [Claude-Jira Integration](https://www.eesel.ai/blog/claude-ai-jira-integration)