Skip to main content
An agent without declared capabilities is a black box. Other agents, orchestrators, and clients have no way to know what it can do, whether it is the right agent for a task, or how to interact with it correctly. Skills solve that. They are the formal declaration of what your agent knows how to do — structured, discoverable, and published as part of the agent card.

​
Why Skills Matter

In a multi-agent network, capability discovery is how work gets routed to the right agent. Without a standard way to declare skills, every integration becomes a custom handshake.
Without skillsWith Bindu skills
Capabilities are implicit or undocumentedSkills are declared in a structured manifest
Orchestrators cannot discover what an agent doesSkills are published at /agent/skills
Task routing requires manual configurationAgents can be matched to tasks by capability
No standard input/output contractEach skill defines its expected I/O
Fine for single-agent scriptsRequired for multi-agent systems
That is the shift: skills turn an agent from a private script into a discoverable, composable node in the Internet of Agents.
Skills are defined in a skills/ directory inside your project. Bindu reads them automatically during bindufy and exposes them via the agent card and the /agent/skills endpoint.

​
How Bindu Skills Work

A skill is a directory inside skills/ that contains a skill.json manifest. The manifest describes the skill’s identity, input schema, output schema, and any configuration it needs.

​
The Skills Model

A minimal skill looks like this: 
skills/
└── question-answering/
    └── skill.json

{
  "id": "question-answering",
  "name": "Question Answering",
  "description": "Answers questions using web search and reasoning",
  "tags": ["research", "search", "qa"],
  "examples": [
    "What is the capital of France?",
    "Summarize the latest news on AI regulation"
  ],
  "inputModes": ["text/plain"],
  "outputModes": ["text/plain"]
}

Declarative

Skills are defined in JSON. No code required to declare what your agent can do.

Discoverable

Published at /agent/skills so orchestrators and other agents can find them.

Composable

Multiple skills per agent. Each skill is independently addressable.

​
The Lifecycle: Define, Register, Discover

1

Define

Create a skills/ directory in your project root. Each subdirectory is a skill, identified by its folder name.
your-agent/
├── main.py
├── agent_config.json
└── skills/
    ├── question-answering/
    │   └── skill.json
    └── summarization/
        └── skill.json
Each skill.json declares the skill’s identity and I/O contract.
2

Register

Reference the skills directory in your agent config:
{
  "author": "your.email@example.com",
  "name": "research_agent",
  "description": "A research assistant agent",
  "version": "1.0.0",
  "skills": ["skills/question-answering", "skills/summarization"],
  "deployment": {
    "url": "http://localhost:3773",
    "expose": true
  }
}
Bindu reads the manifests during bindufy and registers them automatically. No additional code is needed.
3

Discover

Once the agent is running, skills are available at two endpoints:
# Full agent card including skills
curl http://localhost:3773/.well-known/agent.json

# Skills only
curl http://localhost:3773/agent/skills

[
  {
    "id": "question-answering",
    "name": "Question Answering",
    "description": "Answers questions using web search and reasoning",
    "tags": ["research", "search", "qa"],
    "inputModes": ["text/plain"],
    "outputModes": ["text/plain"]
  }
]

​
The Skill Manifest

The skill.json file is the complete definition of a skill. All fields except id and name are optional, but the more you declare, the more useful the skill is for discovery and routing. 
{
  "id": "question-answering",
  "name": "Question Answering",
  "description": "Answers questions using web search and reasoning",
  "tags": ["research", "search", "qa"],
  "examples": [
    "What is the capital of France?",
    "Who won the 2024 Nobel Prize in Physics?",
    "Summarize the latest news on AI regulation"
  ],
  "inputModes": ["text/plain"],
  "outputModes": ["text/plain", "application/json"]
}

​
Fields

FieldRequiredDescription
idYesUnique identifier for the skill, matches the directory name
nameYesHuman-readable name shown in the agent card
descriptionNoWhat the skill does — used for capability matching
tagsNoKeywords for discovery and routing
examplesNoSample inputs that demonstrate the skill
inputModesNoMIME types the skill accepts (default: text/plain)
outputModesNoMIME types the skill produces (default: text/plain)

​
Multiple Skills

An agent can declare as many skills as it has capabilities. Each skill is independently addressable and can have its own I/O contract. 
skills/
├── question-answering/
│   └── skill.json
├── summarization/
│   └── skill.json
├── data-analysis/
│   └── skill.json
└── code-review/
    └── skill.json

{
  "skills": [
    "skills/question-answering",
    "skills/summarization",
    "skills/data-analysis",
    "skills/code-review"
  ]
}
All declared skills appear in the agent card and the /agent/skills response. Orchestrators can inspect the full list and route tasks to the most appropriate skill.

​
Skills and Task Routing

In a multi-agent system, an orchestrator fetches the skills of available agents and matches incoming tasks to the right agent based on skill tags, descriptions, and examples. The orchestrator does not need to know the agent’s internals. The skill manifest is the contract.

​
Real-World Use Cases

A research agent might declare question-answering, summarization, and web-search as separate skills. An orchestrator can route a summarization task directly to the right skill without guessing.
{
  "skills": [
    "skills/question-answering",
    "skills/summarization",
    "skills/web-search"
  ]
}
A focused agent that only does one thing well. Declaring a single skill makes its purpose unambiguous and easy to route to.
{
  "id": "code-review",
  "name": "Code Review",
  "description": "Reviews Python code for bugs, style, and security issues",
  "tags": ["code", "python", "review", "security"],
  "inputModes": ["text/plain", "text/x-python"],
  "outputModes": ["text/plain", "application/json"]
}
In a swarm, each agent declares its skills. The orchestrator builds a capability map at startup by fetching /agent/skills from every agent, then routes tasks dynamically based on what each agent can do.

​
Project Structure

The create-bindu-agent template scaffolds the skills directory for you: 
your-agent/
├── main.py                    # Agent entry point
├── agent_config.json          # Config referencing skills
└── skills/
    └── question-answering/
        └── skill.json         # Starter skill manifest
You can add more skills by creating new subdirectories under skills/ and adding a skill.json to each one.
Sunflower LogoSkills are how agents introduce themselves to the network - not by what they are, but by what they can do.