菜单
Use when selecting or comparing agentic frameworks (LangChain, LangGraph, CrewAI, AutoGen, etc.) — curated comparison by use case, language, and maturity. Gets latest context via Context7 when available. NOT for reviewing existing agentic code (use review-methodology) or architecture patterns (use agentic-patterns).
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
基于 SOC 职业分类
| name | wicked-garden-agentic-frameworks |
| description | Use when selecting or comparing agentic frameworks (LangChain, LangGraph, CrewAI, AutoGen, etc.) — curated comparison by use case, language, and maturity. Gets latest context via Context7 when available. NOT for reviewing existing agentic code (use review-methodology) or architecture patterns (use agentic-patterns). |
| portability | portable |
| phase_relevance | ["design","review"] |
| archetype_relevance | ["*"] |
Comprehensive guide to agentic frameworks, their strengths, and how to choose the right one.
| Framework | Language | Best For | Maturity | Learning Curve |
|---|---|---|---|---|
| Anthropic ADK | TypeScript | Claude-specific, production | High | Low |
| LangGraph | Python | Complex workflows, state | High | Medium |
| CrewAI | Python | Role-based teams | Medium | Low |
| AutoGen | Python | Multi-agent conversations | Medium | Medium |
| Pydantic AI | Python | Type-safe agents | Medium | Low |
| OpenAI Agents SDK | Python | OpenAI-specific | Low | Low |
| LlamaIndex Agents | Python | RAG-heavy applications | High | Medium |
| Haystack | Python | Production pipelines | High | Medium |
| Semantic Kernel | C#/Python | Microsoft ecosystem | Medium | Medium |
| LangChain | Python | Rapid prototyping | High | Medium-High |
| Agency Swarm | Python | OpenAI Assistants API | Low | Low |
| Dify | Low-code | No-code workflows | Medium | Very Low |
Simple Sequential:
Complex Workflows:
Team-Based:
No Built-in State: LangChain, Pydantic AI
Checkpointed State: LangGraph (built-in), ADK (context preservation)
Distributed State: Custom implementation needed for all
Extensive Tool Libraries: LangChain (largest ecosystem), LlamaIndex (RAG-focused), Haystack (production tools)
Easy Tool Definition: Pydantic AI (type-safe), ADK (TypeScript decorators), OpenAI Agents SDK (function calling)
Custom Tools: All frameworks support custom tools
Built-in Retry/Fallback: ADK (comprehensive), LangGraph (error handling nodes), Haystack (pipeline error handling)
Manual Error Handling: CrewAI, AutoGen, Pydantic AI
Native Tracing: LangSmith (for LangChain/LangGraph), Braintrust (for ADK)
Third-Party Integration: All support OpenTelemetry, most support LangFuse, Arize
See refs/framework-profiles-1.md (ADK, LangGraph, CrewAI) and refs/framework-profiles-2.md (AutoGen, Pydantic AI, LlamaIndex) for detailed profiles.
Best for: Production Claude applications Strengths: TypeScript with type safety, built-in context management, comprehensive error handling, delegated workflows Weaknesses: Claude-only, TypeScript/Node only, smaller community When to choose: Building on Claude exclusively, TypeScript/Node stack, need production-ready patterns
Best for: Complex stateful workflows Strengths: State machine abstraction, built-in checkpointing, human-in-the-loop support, time-travel debugging Weaknesses: Steeper learning curve, can be overkill, more boilerplate When to choose: Complex workflows with branches/loops, need state persistence, want human approval gates
Best for: Role-based agent teams Strengths: Intuitive role/task abstraction, simple API, good for hierarchical teams Weaknesses: Less mature, limited state management, fewer production features When to choose: Team-based workflows, quick prototyping, straightforward delegation
Best for: Multi-agent conversations Strengths: Flexible conversation patterns, group chat capabilities, human-in-the-loop Weaknesses: Can be verbose, conversation management complexity When to choose: Agents need to debate/collaborate, conversational workflows
Best for: Type-safe Python agents Strengths: Type safety via Pydantic, simple clean API, dependency injection, multi-provider Weaknesses: New/less mature, smaller ecosystem, limited orchestration patterns When to choose: Want type safety, simple agent use cases, already using Pydantic
Best for: RAG-heavy applications Strengths: Excellent retrieval capabilities, query planning, tool use with data Weaknesses: Best for RAG use cases, heavier framework When to choose: Heavy RAG requirements, complex data retrieval, query planning needs
Start: What's your primary use case?
├─ Complex stateful workflow with branches/loops
│ └─ Use: LangGraph
├─ Role-based team of agents
│ └─ Use: CrewAI or ADK
├─ RAG-heavy application
│ └─ Use: LlamaIndex Agents
├─ Multi-agent conversations/debates
│ └─ Use: AutoGen
├─ Simple sequential workflow
│ ├─ TypeScript?
│ │ └─ Use: ADK
│ └─ Python?
│ └─ Use: Pydantic AI or LangChain
├─ Production pipeline
│ └─ Use: Haystack or ADK
└─ Maximum flexibility
└─ Build from scratch or use LangGraph
Python Frameworks: LangChain, LangGraph, CrewAI, AutoGen, Pydantic AI, LlamaIndex
TypeScript Frameworks: Anthropic ADK
C# Frameworks: Semantic Kernel
Multi-Provider (LLM-agnostic): LangChain, LangGraph, CrewAI, AutoGen, Pydantic AI
Single-Provider (Optimized): ADK (Claude), OpenAI Agents SDK (OpenAI)
Most Production-Ready: Anthropic ADK, LangGraph, Haystack, LlamaIndex
Good for Production: CrewAI, LangChain, AutoGen
Early/Experimental: Pydantic AI, OpenAI Agents SDK, Agency Swarm
Build from scratch if: very simple use case, specific requirements unmet, want maximum control, or learning exercise. Framework overhead not worth it for single LLM calls, static prompts, or no agent behavior.
Just getting started: CrewAI or Pydantic AI | State management: LangGraph | TypeScript: ADK | RAG: LlamaIndex | Team-based: CrewAI or ADK | Max flexibility: LangGraph | Production Claude: ADK
refs/framework-profiles-1.md - ADK, LangGraph, CrewAI detailed profilesrefs/framework-profiles-2.md - AutoGen, Pydantic AI, LlamaIndex profiles + comparison matrixrefs/migration-patterns-paths.md - Common migration paths between frameworksrefs/migration-patterns-testing.md - Migration testing, rollback, and effort estimatesv11 work-shape archetype runner. When a prompt has been routed to one of the archetypes (triage, explore, specify, decide, ship, review, incident, build, migrate, modernize), this skill is the entry point. It picks the right per-archetype playbook from refs/ and executes the phase shape declared in `.claude-plugin/archetypes.json`. Use when: a `<wg archetype="X">` or `<wg archetypes>` system-reminder tag appears, an explicit "let's run the X archetype" request, or a direct per-archetype ask — "triage this prompt", "review this PR / artifact", "build this feature", "decide between these options", "explore this problem", "handle this incident", "run this migration", "modernize / port this legacy app", "ship this release", "write acceptance criteria" (invoke with archetype=<name> plus the user's args — see the Direct invocation table).
Pattern-conformance agent-half: evaluates a produced artifact or diff against a set of architectural/design pattern rules from the conformance-rule store (wicked_governance schema). Returns structured findings with rule ID, severity, and rationale — the deterministic half (mechanical rule recall) is done by the guard pipeline; this is the semantic evaluation step. Triggered by: the guard_pipeline `outgov_pattern` check (session-close), or explicitly by an engineering review when WICKED_OUTGOV_RULES_DIR is populated. NOT a replacement for the full `engineering` review skill — focuses only on conformance to stored Pattern rules; architecture and code-quality checks live in the `engineering` skill. Semantic evaluation reuses `wicked-garden-qe-semantic-reviewer` as the designated agent-half evaluator (per garden#983 spec). This skill is the orchestrating wrapper that loads applicable Pattern rules and delegates the per-rule semantic judgment to qe-semantic-reviewer.
Coverage evaluator + pre-build threat model for the domain-extraction workflow (CONTRACT-3 §2). Emits `coverage-report.json` from the estate store, then adversarially reviews the extracted domain model: hunts missing error paths, ungrounded rules, reason-less drops, cross-cluster smears, and coverage holes. Use when: dispatched as the `coverage` phase of a domain-extraction workflow run. The phase runs in a git worktree; WICKED_ESTATE_DB points at the live estate store. NOT for mining rules (domain-extractor) or grouping domains (domain-modeler). This worker EMITS coverage evidence AND CRITIQUES the domain model.
Core utility surface for the wicked-garden plugin: help/overview, first-run setup + codebase onboarding, the wicked-* peer installer, selective state reset, the where-am-i path manifest, and structured issue filing. Use when: "wicked-garden help", "show wicked-garden commands", "what can wicked-garden do", "set up wicked-garden", "setup", "--reconfigure", "onboard this codebase", "install wicked tools", "add peers", "install layers", "reset wicked-garden", "clear state", "--list-projects", "where am I", "path manifest", "report issue", "file a bug", "--list-unfiled", or any former /wicked-garden:{help|setup|install|reset| where-am-i|report-issue} invocation.
Rule-extraction fork worker for the FOUNDATIONAL domain-model capability. Mines testable business rules from a codebase — each with a numeric confidence and a provenance{source, ref, source_kinds} — and annotates them into the estate store so wicked-core can build the domain-model requirements graph (coverage-gated). This is a substrate, not a modernization tool: the `modernize` archetype DERIVES from it, and build / migrate / review / specify / explore can consume the same domain model — none OWN it. Use when: dispatched by wicked-garden-domain to mine the business_rules of a codebase (or a module); "extract the domain rules", "what does this system require", building the requirements half of a domain model. NOT for grouping into domains (that is domain-modeler) or judging coverage (that is domain-coverage — a seat-distinct evaluator).
Domain-graph fork worker for the modernize archetype. Groups the estate's Louvain communities into business domains, attaches each requirement to its cluster (advisory cluster_id provenance), and invokes wicked-core's domain-graph build (which reads the annotated estate store, recomputes coverage fail-closed, and builds the requirements graph) — then validates core's output against the vendored schema. Use when: dispatched by wicked-garden-domain after rule extraction to turn a flat rule set into cluster-keyed domains; "group these into domains", "build the requirements graph", "translate clusters into a domain model". NOT for mining the rules themselves (that is domain-extractor) or threat-modeling (that is domain-coverage).