Skills
A reusable method you teach once. Every agent can use it.
A skill is a reusable way to teach agents how your team does specific work, from writing in your voice to following a research process, calling an API, or producing a report in the right format.
More than instructions
A good thread often reveals a better way to work. Maybe the agent found the right research pattern, produced the report in the format your team prefers, followed your writing voice, or figured out how to use an API that matters to your workflow.
For example, a weekly pipeline thread might teach the agent which CRM fields matter, how your exec team wants risks called out, and what format the final update should follow.
A skill turns that method into something repeatable. Instead of explaining the process again in every thread, you capture it once and make it available to the agents that need it.
That's the shift: a skill isn't just extra context. It's a way to teach agents how work should be done.
What skills can teach
Skills can capture different kinds of reusable methods:
🔁Workflows
✍️Voice and Style
🔎Research Methods
🧱Structure
🔌Tool and API Methods
⚙️Scripted Operations
Skills That Come With Hyperagent
Hyperagent includes global skills that every agent can use. They teach the built-in tools their craft: media generation, composed video, file conversion, data-connection setup, and context building. Your own skills are where you capture team process, voice, formats, and domain expertise.
From thread to skill
Skills usually come from work you've already shaped once. The agent pulled the data, found the risky deals, drafted the exec update, and you refined the output until it matched how your team talks about revenue.
That process is worth saving. In the thread, you can ask Hyperagent to suggest a skill based on the output you just created. It can identify the repeatable method and draft a skill you can review, edit, and save to your Hyperagent workspace.
A Weekly Pipeline Summary skill can capture the method: which CRM fields to check, how to compare this week to last week, what counts as a risk, and how leadership wants the update structured.
The skill holds the repeatable part, not the one-off details. Current deals, dates, and numbers stay in the thread, table, or connected system. Once the skill is saved, you can make it available to agents so they can call on that method when the request is relevant.
Anatomy of a skill
Before a skill can help an agent, it needs a clear label, a clear purpose, and enough instruction for the agent to follow the method.
A Weekly Pipeline Summary skill, for example, should say when to use it, which source to query, what the summary should include, and what format the team expects.
| Part | What it does | Why it matters |
|---|---|---|
| Name | Gives the skill a clear label. | This is what you and the agent use to recognize or mention the skill. Specific names are easier to find and use. |
| Description | Summarizes what the skill helps the agent do. | A good description makes the skill easy to understand at a glance. |
| When to use | Defines the situations where the skill should apply. | This tells the agent what kind of request the skill is meant for. |
| Documentation | Contains the method: steps, examples, constraints, inputs, and what good output looks like. | This is the core of the skill. It tells the agent how to follow the method. |
| Scripts | Optional code the agent can run. | Useful for repeatable mechanics like API calls, calculations, file transforms, or data cleanup. |
| Credentials | Optional API keys or tokens for scripts. | Lets the skill work with external services without exposing raw credential values in conversation. |
How an agent uses skills
Once a skill exists, the agent needs a way to bring it into the thread. That starts with Skill Discovery, an agent setting that controls whether the agent can find skills as the run develops.
With Skill Discovery on, the agent starts with pinned skill summaries and can search for other skills when the task calls for them. With Skill Discovery off, the agent does not search broadly. It uses the skills attached to that agent and preloads their documentation upfront.
How skills enter a thread
📌Pinned
The skill summary loads at the start of every thread.
🔍Discovery on
The full method loads on demand when the task matches.
📦Discovery off
Attached skill docs start in context. Agent doesn't search outside these.
Pinned skills are visible from the start. A pinned skill is part of the agent's default job. The agent sees the skill's name and description at the start of the thread, so it can recognize when that method applies. A RevOps agent might keep a Weekly Pipeline Summary skill pinned because that workflow is central to its job.
With Skill Discovery on, other skills can be found when needed. If a skill is not pinned, the agent can still search for it when the task calls for that method. The agent uses the skill's name, description, and when-to-use field to decide whether it matches the request.
With Skill Discovery off, attached skills are preloaded. The agent starts with the full documentation for its attached skills and does not search across all skills. This can work well for a small, fixed set of skills, but it uses more context from the start.
How agents find the right skill
With Skill Discovery on, the agent does not carry every skill's full instructions from the start. It starts with pinned skill summaries, then searches when a task points to a method it may need.
This is why clear skill fields matter. A skill called "Weekly Pipeline Summary" with a when-to-use field like "Use when preparing recurring sales pipeline summaries for leadership" is easier for the agent to find than a generic skill called "Reporting."
Naming a skill in your message
If you type a skill's name in your message, such as "use the Weekly Pipeline Summary skill," the agent searches for it, loads the full documentation, and follows it. You do not need to attach or pin the skill first, as long as the agent's scope allows the search.
How settings control access
The Skill Discovery setting controls two things at once: whether the agent discovers skills on demand or preloads a fixed set, and whether it can search all skills or only the ones attached to that agent.
🔍Discover
The agent starts with pinned skill summaries. Other skills are found only when the request calls for them.
- Pinned skills are visible from the start.
- Other skills are searched for on demand.
- Full documentation loads only when matched.
- Context stays lean, with more room for the conversation.
📦Preload
Every accessible skill's full documentation is loaded into context at the start of every thread.
- No search is needed because the docs are already present.
- The agent has the full method from the start.
- Context fills up faster.
- Best for agents with a small, fixed set of skills.
Search scope
Search scope controls how far the agent can look when it needs a skill that is not already visible.
🌐All skills
The agent can discover any skill in your knowledge base, even if it is not explicitly attached.
Use when: You want a well-built skill to be available everywhere without manually attaching it to every agent.
🔗Attached only
The agent can only find skills you have explicitly linked to it in agent settings.
Use when: You want tighter control, like a shared agent in a team Slack channel that should not pick up skills from other workflows.
In agent settings, the Skill Discovery toggle controls these choices together. Turning it on uses Discover mode with access to all skills. Turning it off uses Preload mode with access limited to attached skills.
How skills help every agent improve
Skills are portable across agents. That is what makes them compound.
You might build a Weekly Pipeline Summary skill while working with your RevOps agent. Once it works, the same method can help a Chief of Staff agent prep leadership updates, a Sales Manager agent review team performance, or a Data Analyst agent turn CRM changes into a cleaner table.
When the method is ready for other people, you can share it in a team workspace. Teammates can use the same skill without rebuilding the process themselves, and Teams gives you control over credentials: no credentials, the owner's credentials, or each person bringing their own key.
Learn more about skill sharing in Teams.
When you improve the skill, every agent using it benefits. Update the summary checklist, tighten the writing examples, add a script, or fix the API method once, and the improvement travels everywhere the skill is used.
This is different from putting instructions in a system prompt. A system prompt belongs to one agent. A skill can travel to the agents that need the method.
Skills vs. agents
Agents and skills work together, but they are not the same thing.
An agent is the configured teammate: its identity, instructions, tools, integrations, and the outcome it is meant to own. A skill is a reusable method that agent can call when the request requires it.
The Weekly Pipeline Summary is not the agent. It is the method. A RevOps agent might use it to track revenue movement, a Chief of Staff agent might use it to prepare leadership updates, and a Sales Manager agent might use it to review team performance.
| Agent | Skill |
|---|---|
| The teammate configured for a role or outcome | The method that teaches how a specific output or workflow should be handled |
| Has identity, instructions, tools, integrations, and knowledge | Has steps, examples, scripts, credentials, and when-to-use guidance |
| Examples: RevOps agent, Chief of Staff agent, Sales Manager agent | Examples: Weekly Pipeline Summary, Brand Voice Guide, API Query Method |
How skills differ from other context
Skills work alongside memories, tools, and integrations, but they solve a different problem.
| Concept | What it gives the agent | Example |
|---|---|---|
| Skill | How to handle a specific output or workflow | "Write a client brief in our format" or "query this API safely" |
| Memory | Facts or preferences the agent should remember | "Weekly summaries go to #exec-updates" |
| Tool | A built-in action the platform can take | Web search, image generation, code execution |
| Integration | Access to a connected service | Slack, GitHub, Gmail, Google Sheets |
Tools and integrations give the agent capabilities and access. Memories give it context. Skills teach it the method.
Skill FAQs
A skill is a reusable method that teaches agents how to handle specific workflows and outputs. It can be a process document, a writing guide, a research method, an API workflow, or a script-backed operation. Skills compound because one improvement can help every agent that uses the skill.