- name
SKILL.md
스킬 파일은 게시자의 저장소에 그대로 있습니다.
복사한 명령을 터미널에 붙여넣습니다. 이 SKILL.md가 해당 에이전트에 설치됩니다.
npx skills add agentsope/SkillAlchemy --skill agentsop-framework-selection -a cursor -y복사한 명령을 터미널에 붙여넣습니다. 이 SKILL.md가 해당 에이전트에 설치됩니다.
npx skills add agentsope/SkillAlchemy --skill agentsop-framework-selection -a claude-code -y복사한 명령을 터미널에 붙여넣습니다. 이 SKILL.md가 해당 에이전트에 설치됩니다.
npx skills add agentsope/SkillAlchemy --skill agentsop-framework-selection -a codex -y복사한 명령을 터미널에 붙여넣습니다. 이 SKILL.md가 해당 에이전트에 설치됩니다.
npx skills add agentsope/SkillAlchemy --skill agentsop-framework-selection -a grok -y복사한 메시지를 Grok Bot 채팅에 보냅니다. Bot이 GitHub에서 이 SKILL.md를 가져와 모든 Bot이 공유하는 스킬에 추가합니다.
Install this skill: https://github.com/agentsope/SkillAlchemy/tree/HEAD/skills/agentsop-framework-selection게시자 제공
Overlay posture: this is the capstone Phase-D skill — the most-cited entry at any project kickoff. It decides which layer(s) you need and which framework owns each layer. It does not teach any framework's API; for that, descend to the per-framework SOPs (
langgraph-sop,llamaindex-sop,dspy-sop,crewai-sop,vllm-sop,aider-sop,dify-sop). Every load-bearing claim carries an inline source tag resolving inreferences/R1-decision-tree.md.Neutrality note: vendor pages each claim the center of the universe (LangChain: "use LangGraph for production"; LlamaIndex: "the document agent platform"; Dify: "scaffolding is the bottleneck"). This skill quotes those claims but does not adopt any of them. The 7 SOPs disagree on the crossover points; we surface the disagreements rather than papering over them.
Activate when any of the following fire:
pip install an orchestration / RAG / agent framework
before having articulated what layers the project needs.Do not re-run this skill mid-implementation for a layer already chosen — that
is churn. Run it once at kickoff, and again only when a new layer appears
(e.g., "we now need to self-host the model" → triggers [[agentsop-llm-engine-selection]]).
Mental check: the wrong framework is the single highest-cost decision in the project — it is a one-week-to-reverse mistake, sometimes a one-month one.
crewai-sop · OP-1,vllm-sop · OP-7. Spend 20 minutes on this tree before opening any tutorial.
Frameworks are layers, not competitors. The single most common kickoff error is treating "LangChain vs LlamaIndex vs DSPy vs CrewAI vs vLLM" as a horse race with one winner. They are not on the same axis. A mature LLM system is a stack:
┌─────────────────────────────────────────────────────────────┐
│ L7 App platform / UI / Auth │ Dify, Flowise, LangFlow │ ship-fast scaffolding
├─────────────────────────────────────────────────────────────┤
│ L6 Serving / inference │ vLLM, SGLang, llama.cpp … │ → see [[agentsop-llm-engine-selection]]
├─────────────────────────────────────────────────────────────┤
│ L3 Orchestration / control │ LangGraph, CrewAI, Workflows │ → see [[agentsop-agent-topology-selection]]
├─────────────────────────────────────────────────────────────┤
│ L2 Retrieval / context │ LlamaIndex, Haystack │ ingestion, index, query
├─────────────────────────────────────────────────────────────┤
│ L1 Modeling / prompt-compile │ DSPy, Outlines, Guidance │ the LM call itself
├─────────────────────────────────────────────────────────────┤
│ Coding-agent surface (cross) │ Aider, Cline, Cursor … │ end-user product, not a layer
└─────────────────────────────────────────────────────────────┘
DSPy's own ecosystem doc draws this layering explicitly — DSPy "sits underneath
LangChain, LlamaIndex, LangGraph as a compiler for individual LM calls"
dspy-sop · R5. LlamaIndex's doc says "many production systems use both:
LlamaIndex as the retrieval layer, LangGraph as the orchestration layer"
llamaindex-sop · R5. Dify's doc describes the hybrid "Dify for frontend/RAG/auth
dify-sop · R5. The convergence is
unanimous: choose per layer, then check interop.Three corollaries:
dspy-sop · R5. DSPy+LangChain or DSPy+CrewAI are a
"smell" — both are L1-ish prompt strategies fighting for the same slot
dspy-sop · R5.The kickoff procedure runs as numbered steps (Pass A = Steps 1–6, Pass B = Step 7, Pass C = Step 8):
Pass A — Identify the layers you actually need. Walk the stack top to bottom and mark each layer needed / not-needed for this project:
L1 Modeling — Is there ≥1 non-trivial LM call whose prompt will be iterated, swapped across models, or whose output is parsed by code? (Almost always yes.)
L2 Retrieval — Does the system answer over private / large / changing data it cannot fit in context? (Yes → need retrieval. No → skip.)
L3 Orchestration — Is there cycle / branch / memory-across-turns / human approval / >1 coordinating agent? (Yes → need orchestration. A single straight- line call → skip; raw SDK suffices.)
L6 Serving — Are you hosting open-weights models yourself (vs calling a hosted
API)? (Yes → [[agentsop-llm-engine-selection]]. No → skip.)
L7 App platform — Do non-engineers (PM/ops) need to co-author or operate the app, or do you need UI+API+auth+logging out of the box? (Yes → consider a platform. No → code framework.)
Coding-agent surface — Is the deliverable code edits in a repo? (Yes →
[[agentsop-repo-state-gating]] then Aider/Cline/Cursor. This is orthogonal to L1–L7.)
Pass B — For each needed layer, apply the per-layer fit rubric (§4). Each layer has its own short decision tree; do not let one framework's gravity pull you into using it for a layer it is weak at.
Pass C — Check interop and the "do you even need a framework?" gate. Confirm the chosen pieces compose (additive, not same-layer collisions — §7 interop map), and run gate G0 on each layer to confirm a framework beats raw SDK there.
Output of the procedure: a one-line-per-layer decision, e.g.
L1: raw prompts (will revisit DSPy at 30 labeled examples) · L2: LlamaIndex · L3: LangGraph · L6: hosted API (no self-host yet) · L7: none (code-first).
Before adopting any framework on a layer, confirm raw SDK is insufficient. Frameworks trade dependency-surface and a learning curve for batteries. Raw wins when the layer is trivial:
"If the corpus is small (<100k tokens) and static → no framework needed. Stuff the context window with prompt caching."
llamaindex-sop · R5. "Plain LangChain [or raw SDK]: no cycles, no state-between-turns, no HITL — a single LLM call."langgraph-sop · R5.
Mark each of L1/L2/L3/L6/L7 + coding-surface as needed or not, per §3 Pass A. This is the highest-leverage step: most "wrong framework" pain is actually "picked an L3 tool when the project was L2," or vice versa.
dspy-sop · R5. Combines additively into L3 (compile inside
a LangGraph node) and L2 (compile the synthesizer downstream of a retriever).dspy-sop · R5.dspy-sop · R5).llamaindex-sop · R5. Reach for it whenever private/large/changing data must
be retrieved.llamaindex-sop · R5.dify-sop · R5.llamaindex-sop · R5.aider-sop · R5. The SOPs disagree here (LlamaIndex assumes embeddings
work for code; Aider's evidence says repo-map beats them) — for code, prefer the
repo-map; for prose, prefer embeddings (§6).First gate through [[agentsop-agent-topology-selection]] (single-agent + tools handles
~80% of "multi-agent" asks crewai-sop · DC-1). Then, if orchestration is needed:
create_react_agent (LangGraph),
dspy.ReAct, a CrewAI single Agent, or a plain SDK tool loop. Start here.interrupt()), time-travel debugging, or
supervisor/swarm/hierarchical parallelism langgraph-sop · R5. The 2026
production-reliability leader.crewai-sop · R5. Trade-off: shallow
state, thin eval, no built-in persistence.llamaindex-sop · R5.crewai-sop · R5.crewai-sop · R5,
langgraph-sop · R5. OpenAI Swarm — study/reference only, not production.If self-hosting open-weights models: hand off entirely to [[agentsop-llm-engine-selection]].
One-line summary of that skill's rubric: production+GPU+concurrent → vLLM (the
2026 default); prefix-heavy agent/RAG → A/B SGLang; NVIDIA-locked + 1–2wk budget →
TensorRT-LLM; CPU/edge/≤1 user → llama.cpp; local dev → Ollama vllm-sop · R5,
vllm-sop · OP-7. If calling a hosted API (OpenAI/Anthropic/…), skip L6 entirely.
dify-sop · R5. Visual DAG with Code-node escape hatch.dify-sop · R5.dify-sop · R5.dify-sop · R5.dify-sop · R5.If the deliverable is code edits in a repo, gate through [[agentsop-repo-state-gating]]
(Aider et al. are for existing repos; greenfield → plain LLM chat
aider-sop · R5). Then: terminal + git-clean history + scriptable → Aider;
per-tool-call approval in VS Code → Cline; visual/autocomplete + closed product →
Cursor; cross-IDE → Continue; autonomous ticket→PR → OpenHands aider-sop · R5.
This surface is orthogonal to L1–L7 — a coding agent uses L1–L6 internally.
Confirm chosen pieces compose. Additive (good): DSPy-in-node, LlamaIndex-retriever-
as-tool, Dify-frontend + LangGraph-behind-HTTP, vLLM serving any of the above via
its OpenAI-compatible API dspy-sop · R5, dify-sop · R5. Collisions (re-pick):
two L1 prompt strategies; two L3 orchestrators owning the same control flow; a
visual platform asked to do what its code-escape-hatch should.
Tension. Both are L3 orchestrators; they pick different first abstractions.
LangGraph: "everything is a node in a state graph." CrewAI: "everything is a role
on a team" crewai-sop · R5. The SOPs openly concede there is no clean rubric
for the crossover — CrewAI itself recommends "prototype on Crew, port to
LangGraph for production," which concedes the disagreement
phase-b · open-questions.
Resolution. Decide on two axes:
crewai-sop · R5.langgraph-sop · R5.crewai-sop · R5. The standard arc is prototype on
CrewAI → port critical paths to LangGraph.Tension. Framework gravity says "always use the framework." But every
framework is a dependency surface and a learning curve, and on a trivial layer it
is pure overhead dify-sop · R5 (Dify's own doc: "for teams whose bottleneck is
expressive depth, Dify is overhead").
Resolution. Run G0 per layer. Raw SDK wins when: a single LM call with no
cross-turn state and no metric (L1); a corpus under 100k tokens that fits in
context with prompt caching (L2 llamaindex-sop · R5); control flow that fits in
plain if/else with no HITL (L3 langgraph-sop · R5). The DSPy line-count table
is instructive but not a reason to pick a framework — fewer lines on a task that
doesn't need compilation is a false economy dspy-sop · R5. Pick the framework
the moment you cross the threshold, not before.
Tension. Visual builders let PM/ops co-author and ship in days; code
frameworks give expressive depth. Picking visual too early wastes the
scaffolding savings; picking code too early excludes non-engineers
dify-sop · R5.
Resolution. Start visual (Dify) when the bottleneck is scaffolding and a
mixed-role team must operate the app; plan the code-escape hatch up front
(Code nodes, or externalize logic behind HTTP). Migrate to a code framework when
you hit Dify's stated ceilings: single graph >~40–50 nodes (canvas/comprehension
collapse), need for pause-wait-resume / time-travel (Dify explicitly does not
support HITL — issue #21455 "not planned"), sustained >10 QPS/pod, or extreme RAG
experimentation dify-sop · R5, phase-b · open-questions. Note the threshold
numbers are Dify-engine-specific and uncorroborated by other SOPs — treat as
directional, not gospel (§6).
Tension. A "RAG agent" needs both L2 and L3; which framework do you build
around? LlamaIndex frames itself as "the document agent platform"
llamaindex-sop · R5; LangChain frames LangGraph as the production orchestrator
langgraph-sop · R5. Both want to be the spine.
Resolution. Let the dominant difficulty lead. If the hard part is messy
documents / retrieval quality, build around LlamaIndex (with LlamaParse) and add
LangGraph only when agentic logic emerges. If the hard part is multi-step
reasoning / many tools / durable state, build around LangGraph and embed
LlamaIndex retrievers as one tool among many llamaindex-sop · R5. They are not
competitors at the same layer — the error is forcing one to do the other's job.
dspy-sop · R5. Choose per layer; compose.dspy-sop · R5. Mixed same-layer adoption is "usually a
smell."dify-sop · R5. The fix is the planned
code-escape hatch (DC-3), not more nodes.langgraph-sop · R5. Don't compare "LangGraph vs vLLM" — defer to
[[agentsop-llm-engine-selection]].crewai-sop · R5, vllm-sop · R5. Adoption-risk is
a first-class selection criterion, not a footnote.Boundary — disagreements this skill does NOT resolve (surfaced honestly per
phase-b · open-questions): the graph-vs-role crossover point (DC-1); Dify's
specific node-count thresholds (DC-3, Dify-specific, uncorroborated);
embeddings-vs-repo-map for code (OP-3 — likely "repo-map for code, embeddings for
prose," but no single SOP states it); and whether JSON-tool-calls degrade
non-code structured outputs (Aider's finding is code-specific — do not
over-generalize).
The full layered map — which framework owns which layer, with interop notes:
Canonical additive stack (2026 consensus): DSPy compiles the LM calls →
LlamaIndex retrieves → LangGraph orchestrates (with HITL + durable state) → vLLM
serves the open-weights model → (optionally) Dify wraps the frontend/auth. Each
piece is best-in-class on its layer and composes cleanly with the next
dspy-sop · R5, llamaindex-sop · R5, dify-sop · R5.
The one-paragraph kickoff answer. Don't ask "which framework?" — ask "which
layers does this project need, and what's the dominant difficulty on each?"
Identify layers (Pass A), pick the best tool per layer with the §4 rubrics (Pass
B), confirm they compose and that each layer actually clears the no-framework gate
(Pass C). Defer serving to [[agentsop-llm-engine-selection]], multi-agent shape to
[[agentsop-agent-topology-selection]], and coding-agent applicability to
[[agentsop-repo-state-gating]]. The frameworks are layers; you are assembling a stack,
not crowning a winner.
|
---name: agentsop-framework-selectiondescription: |---# skills/agentsop-framework-selection/SKILL.mdFAQ
게시자에게서 skills/agentsop-framework-selection/SKILL.md를 다운로드하거나 경로를 복사해 저장소를 엽니다. PlugMCP는 스킬을 목록에 올릴 뿐 파일을 호스팅하지 않습니다.
게시자가 https://github.com/agentsope/SkillAlchemy에서 관리합니다.
Claude, Cursor, Codex, Grok Build는 게시자의 저장소에서 추가한 SKILL.md를 읽을 수 있습니다. Grok Bot은 채팅에서 스킬의 GitHub 폴더 링크를 보내면 설치합니다.