LLM Tool Ecosystem Architecture
Professional Services Framework
Understanding Tool Calling, MCP, Agents, LangChain, and Claude-Specific Features
Executive Summary
These technologies operate at different architectural layers and serve distinct purposes. They're not competing alternatives—they're complementary systems designed to work together.
- Foundation: Tool Calling enables LLMs to request structured actions
- Protocol: MCP standardizes integration across systems
- Orchestration: Agents & Frameworks coordinate complex workflows
- Application: Skills & Commands provide user-facing capabilities
Select Architectural Layer
Tool/Function Calling
The Foundation Layer
Core Capability
• LLM generates structured JSON
• Specifies function + arguments
• ALL systems depend on this
• Model suggests, doesn't execute
• Specifies function + arguments
• ALL systems depend on this
• Model suggests, doesn't execute
MCP
Protocol Layer
Standardization
• Uses tool calling underneath
• Client-server architecture
• JSON-RPC transport
• Dynamic discovery
• Client-server architecture
• JSON-RPC transport
• Dynamic discovery
Universal Protocol
• "USB-C for AI"
• Solves N×M problem
• Vendor-agnostic
• Growing ecosystem
• Solves N×M problem
• Vendor-agnostic
• Growing ecosystem
AI Agents
Autonomous Orchestration
LangChain
Framework Orchestration
Orchestration Layer
Agents: LLM-driven decisions
LangChain: Framework structure
Both manage complex workflows
LangChain: Framework structure
Both manage complex workflows
Claude Skills
Model-Invoked
/Commands
User-Invoked
Invocation Difference
Skills: Automatic activation
Commands: Explicit /trigger
Both: Markdown-based workflows
Commands: Explicit /trigger
Both: Markdown-based workflows
Tool Calling
MCP
Agents
LangChain
Skills
/Commands
Complete Stack
Foundation → Protocol → Orchestration → Application
All layers work together
All layers work together
Color Legend
Tool Calling - Foundation
MCP - Protocol
Agents - Orchestration
LangChain - Framework
Skills - Application
/Commands - Application
Comprehensive Feature Comparison
| Characteristic | Tool Calling | MCP | Agents | LangChain | Claude Skills | /Commands |
|---|---|---|---|---|---|---|
| Architectural Layer | Model capability | Protocol/standard | Orchestration pattern | Framework/library | Application feature | Application feature |
| Primary Purpose | Generate structured function requests | Standardize tool integration | Autonomous task execution | Orchestrate LLM applications | Package domain expertise | Reusable prompt workflows |
| Autonomy Level | None (suggestion only) | Low (executes defined tools) | High (self-directed) | Medium (workflow-directed) | Medium (context-triggered) | None (user-triggered) |
| Planning Capability | No planning | No planning | Multi-step planning | Chain/workflow planning | Predefined instructions | Single execution |
| Memory Management | Stateless | Session-based | Short & long-term memory | Framework-managed | Per-skill state | Stateless |
| Cross-Platform | All LLM providers | Open standard | Framework-agnostic | Multi-provider | Claude only | Claude Code only |
| Best For | Simple API calls | Multi-system integration | Complex autonomous tasks | Structured workflows | Recurring domain tasks | Team workflow shortcuts |
Critical Distinction: Workflows vs. Agents
Anthropic defines two types of agentic systems:
- Workflows: LLMs and tools orchestrated through predefined code paths
- Agents: LLMs dynamically direct their own processes and tool usage
Trade-off: Workflows offer predictability and consistency. Agents provide flexibility and model-driven decision-making at scale.
Architectural Stack & Dependencies
Layer 1: Model Capability (Foundation)
Tool/Function Calling
- What: LLM capability to generate structured function calls
- How: Model outputs JSON with function name + arguments
- Execution: Model DOES NOT execute - your code must
- Dependency: None - this IS the foundation
- Universal: OpenAI, Anthropic, Google, Meta, etc.
⬇
Layer 2: Protocol (Standardization)
Model Context Protocol (MCP)
- What: Open standard for tool integration
- Architecture: Client-server with JSON-RPC
- Components: MCP Client, Server, Host
- Builds on: Tool calling (uses internally)
- Value: Solves N×M problem, dynamic discovery
⬇
Layer 3: Orchestration (Coordination)
AI Agents (Autonomous)
- What: LLM-driven autonomous systems
- Components: Agent core, Memory, Planning, Tools
- Decision-making: Model directs its own process
- Builds on: Tool calling + optionally MCP
LangChain (Structured)
- What: Framework for LLM applications
- Components: Tools, Agents, Chains, Memory
- Decision-making: Predefined workflows
- Builds on: Tool calling + MCP adapters
⬇
Layer 4: Application (User Experience)
Claude Skills (Model-Invoked)
- What: Filesystem-based capability packages
- Structure: SKILL.md + scripts/resources
- Invocation: Automatic (context-triggered)
- Value: Progressive disclosure, automation
Claude /Commands (User-Invoked)
- What: Reusable prompt workflows
- Structure: Markdown with frontmatter
- Invocation: Explicit /command trigger
- Value: Team sharing, explicit control
AI Agents: Deep Dive
What Are AI Agents?
AI Agents are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks. Unlike workflows with predefined paths, agents make autonomous decisions based on their "understanding" of the goal.
Core Agent Components
1. Agent Core (Brain)
- LLM serves as the reasoning engine
- Interprets goals and makes decisions
- Coordinates all other components
2. Planning Module
- Breaks down complex tasks into steps
- Creates execution strategies
- Adapts plans based on feedback
3. Memory System
- Short-term: Current task context
- Long-term: Historical knowledge
- Experience accumulation
4. Tool Integration
- Dynamic tool selection
- Uses tool calling underneath
- Can integrate MCP servers
Agent Execution Flow
1
Goal InterpretationAgent receives high-level goal: "Analyze Q3 sales data and create executive report"
2
PlanningAgent creates plan: (1) Retrieve data, (2) Analyze trends, (3) Generate visualizations, (4) Write report
3
Tool SelectionAgent decides: Use database MCP server → Python for analysis → Visualization library → Document creation
4
Execution & AdaptationAgent executes plan, monitors results, adapts if tools fail or data is unexpected
5
Memory UpdateAgent stores learnings: Q3 patterns, successful tool combinations, report preferences
Agent Challenges & Considerations
Agents trade predictability for flexibility:
- Non-deterministic: Same input may produce different execution paths
- Hallucination risk: Agent may "invent" data or tool capabilities
- Higher latency: Multiple LLM calls for planning and execution
- Higher cost: More tokens consumed for reasoning and iteration
Recommendation: Use workflows for well-defined tasks. Use agents when flexibility justifies the complexity.
Real-World Integration Workflows
Scenario 1: Professional Services RAG System
Goal: Query 50+ GitLab repositories with contextual understanding
1
Foundation: Tool CallingClaude uses tool calling to decide: retrieve from vector DB or generate from knowledge
2
Protocol: MCP ServersGitLab MCP (code access), Qdrant MCP (vector search), Vertex AI MCP (embeddings)
3
Orchestration: Agent (Optional)For complex queries, agent decides: which repos to search, what patterns to identify
4
Application: Claude SkillsSecurity analysis skill auto-activates, applies best practices, generates formatted documentation
Scenario 2: Claude Code Development Workflow
Goal: Streamline development with automated review, testing, and deployment
1
/Commands for Workflows/review, /test, /security-scan, /deploy - Team-shared explicit triggers
2
Skills for AutomationSecurity analysis skill auto-runs on commits, test generation skill activates on new features
3
MCP for IntegrationGitHub MCP (PRs), Linear MCP (tasks), Sentry MCP (errors), Jenkins MCP (CI/CD)
4
Tool CallingEnables Claude to invoke all commands, skills, and MCP tools
Integration Best Practices
Start Simple
Begin with tool calling. Add MCP when you need multiple integrations. Add agents when orchestration becomes complex.
Begin with tool calling. Add MCP when you need multiple integrations. Add agents when orchestration becomes complex.
Right Abstraction
Don't use agents for deterministic workflows. Don't reinvent what MCP solves. Choose the appropriate layer.
Don't use agents for deterministic workflows. Don't reinvent what MCP solves. Choose the appropriate layer.
Consider Lock-in
Open standards (MCP, tool calling) vs. proprietary (Claude features) vs. framework-dependent (LangChain)
Open standards (MCP, tool calling) vs. proprietary (Claude features) vs. framework-dependent (LangChain)
Progressive Enhancement
Foundation → Protocol → Orchestration → Application. Build from bottom up.
Foundation → Protocol → Orchestration → Application. Build from bottom up.
Key Takeaways
🏗️
Different LayersFoundation → Protocol → Orchestration → Application. Each layer builds on the layers below.🤖
Agents Are DifferentAgents provide autonomy at the cost of predictability. Use for complex, adaptive tasks.🔗
They Work TogetherCombine layers strategically. Agents + MCP + Skills is powerful for Professional Services.⚖️
Trade-offs MatterAutonomy vs. control, flexibility vs. predictability, simplicity vs. power.