AGENTS & ORCHESTRATION
The Skills Paradigm
Packaged expertise that compounds
In 30 Seconds
The old way: Build a separate AI agent for each domain. A finance agent, a legal agent, a research agent — each with its own scaffolding, its own tools, its own maintenance burden.
The shift: One general-purpose agent + a library of skills. The agent loads relevant expertise on demand. New domain? Add a skill file.
The next step: That agent can now coordinate teams — multiple instances working in parallel, each loading the skills they need, sharing findings through a shared task list. Skills remain the unit of expertise; teams are the unit of coordination.
Anthropic's realisation: “After we built Claude Code, we realized that Claude Code is actually a general purpose agent.” Skills let any organisation extend AI capability across domains — and teams let that expertise scale across parallel workstreams.
A note on terminology: “Skills” means different things in different AI contexts. This page covers Anthropic-style Agent Skills – filesystem-based expertise packages that load through explicit triggers, not AI-decided retrieval.
If you're confused by terms like “agent”, “agentic”, “skills”, or “workflows”, you're not alone – the industry uses the same words to mean different things. See our AI Agents Explained deep dive for clear definitions.
Why This Matters
For Growing Organisations
You don't need an AI team to build agents. Skills are simple files – instructions, examples, references – that anyone can create.
One person's expertise becomes organisation-wide capability. Knowledge compounds instead of staying locked in individual heads.
For Technical Teams
No more maintaining separate codebases for each domain agent. The runtime is the same – only the loaded context changes.
Version skills in Git. Share them across projects. The infrastructure stays constant while capability grows.
The democratisation: A few companies build AI models. A few more build agent runtimes. But anyone can build skills. This is the layer where domain expertise becomes AI capability.
Skills vs Subagents vs Agent Teams
Three ways to extend what your agent can do
Skills
Procedural knowledge loaded into the main agent's context. The agent reads the skill and knows how to do something new.
What they are
Markdown/text files containing instructions, examples, best practices, and reference material
When to use
“How do I...?” questions. Domain expertise. Standard procedures. Best practices.
Example
Financial reporting skill: templates, regulations, common pitfalls, quality checks
Subagents
Separate agent instances spawned to work autonomously. They run in parallel, with their own context, and return results.
What they are
New agent processes with their own context window, spawned by the main agent
When to use
“Do X for me” tasks. Parallel work. Isolated execution. Long-running operations.
Example
Code review subagent: analyses code independently, returns findings when done
Agent Teams
NEWMultiple agent instances coordinating via shared task lists and message passing. A lead delegates, teammates execute in parallel.
What they are
Coordinated agent instances with shared task lists, mailbox messaging, and a lead/teammate structure
When to use
Large-scope work. Multi-file changes. Tasks that decompose into parallel streams.
Example
Website overhaul: lead plans architecture, teammates build pages in parallel
The simple test: Does the main agent need to know how to do something? Load a skill. Does something need torun independently? Spawn a subagent. Is the work large enough to decompose into parallel streams? Launch a team.
Anatomy of a Skill
Skills are deliberately simple. Here's what goes inside.
Essential Components
Description
What this skill does and when to use it. The agent reads this to decide whether to load the skill.
Instructions
Step-by-step guidance. What to do, in what order, with what considerations. The procedural knowledge itself.
Examples
Show, don't just tell. Good examples of inputs and outputs. What “done well” looks like.
Optional Enhancements
Reference Material
Domain knowledge the agent might need. Definitions, frameworks, regulations, or standards relevant to the skill.
Common Pitfalls
What to avoid. Known failure modes, edge cases, and mistakes to watch for.
Quality Checks
How to verify the work is good. Checklists, validation criteria, or review steps.
The format is intentionally low-tech. Plain text or Markdown. Version in Git. Edit with any tool. No special infrastructure required – just well-organised knowledge.
Types of Skills
Three categories, each serving different purposes
Foundational Skills
New capabilities the agent didn't have before. Domain expertise packaged for AI use.
Document Creation
Reports, proposals, analyses with domain-specific structure
Data Analysis
Statistical methods, visualisation patterns, interpretation frameworks
Research
Literature review, synthesis, citation patterns, source evaluation
Technical Writing
Documentation standards, API references, user guides
Platform Skills
Help agents work better with specific tools and platforms. Usually built by platform providers.
Browser Automation
Web navigation, form filling, data extraction from pages
IDE Integration
Code editing patterns, project navigation, build systems
API Orchestration
Multi-step API workflows, error handling, rate limiting
Database Operations
Query patterns, schema navigation, data migration
Enterprise Skills
Organisation-specific knowledge. Your unique processes, standards, and institutional knowledge.
Internal Processes
How things get done here. Approval flows, standard procedures
Coding Standards
Your team's conventions, patterns, and review criteria
Compliance Rules
Regulatory requirements, audit trails, documentation standards
Domain Knowledge
Industry-specific expertise unique to your organisation
How Skill Loading Works
Progressive disclosure: the right context at the right time
The critical insight: Having agents autonomously decide which skills to load sounds elegant but produces inconsistent results. The most reliable approach uses progressive disclosure – structured layers that load at the right time.
Metadata: Always Available
Skill names and descriptions are always in context. The agent knows what skills exist and roughly what they do – without loading the full content.
Example: “financial-reporting: Guides creation of compliant financial reports”
Instructions: Loaded When Triggered
Full skill instructions load through explicit triggers – a command, a workflow step, or a clear user request. Not autonomous guessing, but clear activation.
Example: User says “prepare the quarterly report” → financial-reporting skill activates
Resources: Retrieved As-Needed
Reference materials, examples, and templates are fetched during execution when specific information is needed – not loaded upfront.
Example: When creating a variance analysis, retrieve the variance template and examples
Reliability
Explicit triggers produce consistent results. Autonomous skill discovery introduces randomness – the agent might load the wrong skill or miss one entirely.
Efficiency
Loading only what's needed preserves context window for actual work. Dumping all potentially-relevant content wastes tokens and confuses the agent.
The principle: The agent is always the same. What changes is what it knows. But how that knowledge loads determines whether the system is reliable or unpredictable.
Building Your Skills Library
Start simple, expand based on need
Start Here
Identify Repeated Work
What do you explain repeatedly? What processes follow consistent patterns? These are your first skill candidates.
Capture Expert Knowledge
What does your best person know that others don't? Document it as a skill so AI can apply it consistently.
Start With One Skill
Don't build a library upfront. Create one skill, use it, refine it. Then build the next based on real need.
Grow Over Time
Let AI Create Skills
Agents can write skills too. After completing a task, ask them to document it as a skill for future use.
Version and Share
Skills in Git means version history, collaboration, and sharing across teams or projects.
Refine Based on Use
Skills improve through use. What worked? What was missing? Update the skill file after each significant use.
The compound effect: Each skill created becomes permanent organisational capability. Knowledge stops walking out the door when people leave.
Common Mistakes to Avoid
Building Too Complex
Skills should be simple text files. If you're building elaborate infrastructure, you're overengineering. Start with a markdown file.
Designing Before Using
Don't plan a 50-skill architecture upfront. Build one skill, use it, learn what works. Let the library emerge from real needs.
Forgetting Maintenance
Skills need updating as knowledge evolves. Build review rhythms into your process. Stale skills produce stale outputs.
Hiding Skills in Silos
Skills compound when shared. One team's expertise should become organisation-wide capability. Make skills discoverable.
How We Help
Design, build, and evolve your skills architecture
Skills Discovery
Identify where skills will have most impact. Map your expertise, find the patterns, prioritise what to build first.
Skills Development
Help create your first skills. Extract knowledge from experts. Build the templates and patterns for your organisation.
Architecture Design
How should skills be organised? How do they interact with your agent setup? Design the system that scales.
Build Expertise That Compounds
Skills turn individual expertise into organisational capability. One file at a time, your AI becomes genuinely expert in your domain.
No commitment, no pitch. Just a conversation about where skills could extend your AI capability.
Where To Go Next
Agents & Orchestration
The broader picture: orchestration patterns, human-AI collaboration, and how skills fit into agent architecture.
AI Agents Explained
Clear definitions of AI agents, agentic AI, workflows vs agents, and how to cut through the terminology confusion.
Memory Health Protocol
Why AI forgets and how to fix it. The context engineering that makes skills effective across sessions.
AI Capability Overview
The full picture of how we help organisations build AI capability – context, skills, and orchestration.
Standards: Skills architecture concepts align with Anthropic's Agent Skills specification and the emerging agentskills.io open standard for cross-platform skill portability.
Disclaimer: This content is for general educational and informational purposes only. For specific guidance on AI implementation in your organisation, please consult appropriately qualified professionals.