Today, a friend who works in quantitative trading asked me a question that I think a lot of people are quietly wondering about:

"I keep hearing about agents, subagents, skills, MCP, but what do they actually mean? And how do I use them?"

He's not a beginner. He codes every day, builds trading systems, manages risk models. But like most people, his interaction with AI has been limited to chat interfaces: type a question, get an answer. He knew there was something more, something about orchestrating multiple AI agents to write code, run tests, monitor systems, and automate workflows. He just couldn't piece together how all the concepts fit.

That conversation made me realize: the gap isn't intelligence. The gap is architecture. Most people don't lack access to powerful models. They lack a mental model for how to make those models actually work.

This article is my attempt to bridge that gap. I'll explain the four key concepts as simply as I can, then show how they come together in a real-world scenario.

1. Agent: From "Q&A Machine" to "Employee Who Gets Things Done"

Let's start with the basics.

When you chat with ChatGPT, it answers your question. That's an LLM (Large Language Model). It's smart, but fundamentally passive: you ask, it responds.

An Agent is different. An Agent is an AI system with a goal, a set of tools, and the autonomy to make decisions. You don't give it a question. You give it a task.

Here's the difference. Tell a regular LLM "analyze Apple's latest earnings," and it gives you an analysis based on its training data, which might be months out of date. Give the same task to an Agent, and it will:

• Pull the latest 10-Q filing from the SEC website
• Extract key financial metrics
• Compare against the previous quarter
• Generate an analysis report
• Send it to your inbox

The LLM is thinking. The Agent is doing.

An Agent has three defining characteristics: it can perceive its environment (access external data), plan autonomously (break big tasks into steps), and execute actions (operate tools to complete them). It's more than a model that talks. It's a digital employee with hands and feet.

2. SubAgent: When One Person Can't Do It All, Build a Team

No matter how talented an employee is, they can't do everything alone.

That's why SubAgents exist. If an Agent is an employee, SubAgents represent team collaboration. A lead Agent acts as "project manager," breaking tasks apart and delegating them to multiple SubAgents, each specializing in a different domain, working in parallel.

Anthropic's benchmark data tells a compelling story: the combination of Claude Opus 4 as the lead Agent with Sonnet 4 as SubAgents outperformed single-agent systems by 90.2% on complex research tasks. That's not incremental. It's a qualitative leap.

Why? Three reasons.

First, specialization. Each SubAgent focuses on one narrow domain, just like in a company where you wouldn't ask your accountant to write code or your engineer to negotiate with clients.

Second, parallel processing. The lead Agent can dispatch three to five SubAgents simultaneously, each using multiple tools concurrently. Tasks that would have been processed sequentially can now run in parallel.

Third, context isolation. Each SubAgent maintains its own independent context window. This solves a very real problem. When you cram too many tasks into a single Agent's context, its performance drops sharply. Research shows that token usage explains 80% of performance variance in browsing tasks. Overload a single Agent, and it actually gets dumber.

Back to my friend's scenario. He needs to simultaneously develop and test multiple sets of trading rules. With SubAgents, the system looks like this:

• Orchestrator Agent: Receives a high-level task like "Build complete trading rules for a new momentum strategy"
• Research SubAgent: Searches for relevant market data and academic papers
• Coding SubAgent: Writes code based on the strategy logic
• Testing SubAgent: Runs backtests to validate the code
• Monitor SubAgent: Continuously monitors strategy performance

All five work in parallel, with the Orchestrator aggregating the results. What used to take a full day could now be done in an hour.

3. MCP: The "Universal Adapter" That Connects Agents to the Real World

At this point you might be wondering: Agents and SubAgents sound great, but how do they actually "pull SEC filings," "query databases," or "send emails"?

The answer is MCP, which stands for Model Context Protocol.

Before MCP, connecting AI to external tools meant building a custom connector for every combination. Want to connect to Google Drive? Build one. Slack? Build another. Your internal database? Yet another. With M AI applications and N external tools, you'd need M x N connectors. A maintenance nightmare.

MCP did something simple but profound: it defined a universal standard. Just as USB-C unified all charging ports, MCP unified how AI connects to external systems. Implement MCP once, and you can connect to the entire ecosystem.

Anthropic released MCP in November 2024. By March 2025, OpenAI announced full adoption, followed by Google DeepMind. By late 2025, MCP was donated to the Agentic AI Foundation under the Linux Foundation, becoming an official industry standard. Over 13,000 MCP Servers have been built on GitHub.

What does this mean in practice? It means your AI Agent can now connect to virtually anything:

• Market Data APIs (Bloomberg, Wind): Real-time price queries
• PostgreSQL databases: Direct reads and writes to trading records
• Gmail/Outlook: Automated email alerts when risk thresholds are breached
• GitHub: Auto-commit code changes, create PRs, trigger CI/CD pipelines
• Google Sheets: Auto-populate daily reports into shared spreadsheets

Every one of these used to require substantial glue code. Now, one MCP Server handles it, and any MCP-compatible AI client can use it.

4. Skills: Turning Expertise into Reusable Playbooks

The last key concept: Skills.

If MCP solves "what can an Agent connect to," Skills solve "how does an Agent know what to do."

Anthropic introduced Skills in October 2025. At their core, Skills are folders containing instructions, scripts, and resources that Agents can dynamically load when needed. Think of them as operations manuals. They don't tell an Agent a fact; they teach it a method.

Here's a good analogy. You hire a new employee. Instead of verbally explaining every time how to write a report, conduct a code review, or handle a client complaint, you create an SOP manual. When the employee encounters a relevant task, they open the right chapter and follow the steps. Skills are an Agent's SOP manual.

The elegance of Skills lies in "progressive disclosure." An Agent doesn't load all Skills at once. That would waste precious context window space. Instead, it first scans Skill metadata (name and description), loads full instructions only when relevant, and pulls in scripts only when execution is needed. This means you can have dozens or even hundreds of Skills without slowing the Agent down.

Skills have also been published as an open standard (agentskills.io), meaning your Skills aren't locked to one platform. They work across Claude, Claude Code, the API, and any tool that adopts the standard.

In the quant trading context, useful Skills might include:

• Earnings Analysis Skill: Which metrics to extract, how to calculate quarter-over-quarter changes, what report format to use
• Trading Rules Coding Skill: Naming conventions, test coverage requirements, backtesting framework patterns
• Risk Alert Skill: Trigger conditions, notification workflows, email templates
• Daily Report Skill: Data sources, analysis dimensions, visualization standards

Once created, these Skills are automatically loaded every time the Agent handles a related task. No repeated prompting, consistent output quality.

5. How They All Work Together

Now you understand each component. Let me tie them together with a complete scenario.

Imagine my friend needs to do this every morning:

"Analyze all S&P 500 earnings reports released after yesterday's close. Identify companies that beat or missed consensus. Assess the impact on current holdings. Generate a risk report and send it to the team."

Traditionally, this takes an analyst half a day. With the Agent ecosystem, the entire workflow can be automated:

Step 1: The Orchestrator Agent receives the task and plans the workflow.

It reads the task description, creates an execution plan, and determines which SubAgents are needed.

Step 2: SubAgents execute in parallel.

• Data Collection SubAgent connects to SEC databases and financial APIs via MCP, pulling all overnight earnings filings
• Analysis SubAgent loads the Earnings Analysis Skill, extracts Revenue, EPS, and Guidance following predefined methodology, and compares against consensus
• Portfolio SubAgent connects to the internal holdings database via MCP, cross-referencing which reporting companies are in the current portfolio

Step 3: Aggregation and report generation.

The Orchestrator collects all SubAgent outputs, loads the Daily Report Skill, and generates a complete report in the team's standardized format.

Step 4: Distribution.

The Orchestrator connects to Gmail via MCP and sends the report to the team. If a material risk event is detected, it loads the Risk Alert Skill and triggers an immediate notification.

From task assignment to report delivery: roughly 15 minutes.

6. What This Means for You

You don't need to build any of this from scratch.

The reason I'm explaining these concepts isn't to encourage everyone to go architect their own multi-agent system. For most people, that's neither practical nor necessary. These concepts matter because the tools you already use, or will use soon, are built on this architecture. Understanding it helps you use them better, evaluate them smarter, and adopt them faster.

Products like financial AI research platforms, automated coding assistants, and enterprise workflow tools are increasingly built on Agent + SubAgent + MCP + Skills patterns under the hood. When you understand the architecture, you stop being a passive user and start being someone who can evaluate which tools genuinely deliver value and which are just wrapping a chatbot in a fancy UI.

If you're a developer or a technical leader, there are a few things worth paying attention to. MCP has become the shared standard across Anthropic, OpenAI, and Google. Investment in MCP-compatible tooling won't become obsolete. Skills, as an open standard, mean that domain expertise can be captured once and reused everywhere. And the orchestrator-worker pattern with SubAgents is rapidly becoming the default architecture for any complex AI workflow.

The bottom line: the era of "one chatbox for everything" is ending. The next wave belongs to modular, composable AI systems where specialized Agents collaborate, connect to real data, and follow structured playbooks.

These four concepts are simpler than they sound. Their relationship fits in one sentence:

Agent is the employee. SubAgent is the team. MCP is the tool interface. Skills are the operations manual.

You may not work in quantitative trading, but you almost certainly have repetitive workflows, information scattered across multiple sources, and deliverables that follow a consistent format. Wherever those exist, this architecture can help.

The first step toward understanding is to stop thinking of AI as a chat window, and start thinking of it as a workforce.