> For the complete documentation index, see [llms.txt](https://rootai.gitbook.io/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://rootai.gitbook.io/docs/rootai/skills.md).
# Skills
A skill gives an agent a focused workflow, behavior, and safety boundary. It can guide research, trading analysis, wallet review, strategy design, market investigation, or guarded execution flows.
HoodAgent is currently the first rootAI agent with full Skill Studio and live skill-loading support, but the skill system is designed for Hermes agents broadly, including Cirrus and future rootAI agents.
***
### What a skill is
A skill is a structured instruction set that tells a Hermes agent how to approach a type of task.
A skill can define:
* what the agent should do
* what data it should check
* what tools it should prefer
* what risks it should flag
* what output format it should use
* what actions require confirmation
* what the agent must never do
Example:
A token investigator skill can tell the agent to resolve token identity, check liquidity, compare pairs, flag contract ambiguity, and avoid inventing prices.
A trading skill can tell the agent to prepare a route, check slippage, explain risk, and ask for confirmation before execution.
***
### Where to find skills
Open:
`Agentic Hub → Skill Studio`
Skill Studio is the rootAI skill builder.
It is where users can:
* create skills
* edit skills
* save skills
* copy skills
* delete skills
* submit skills for review
For the current HoodAgent implementation, open:
`Agentic Hub → HoodAgent → Skills`
That panel is where skills can be loaded into the active HoodAgent chat.
***
### Skill sections
The skills panel is organized into sections.
#### My Skills
Your private saved skills.
Only you can see these.
You can edit, copy, delete, and use them.
#### Built-in Skills
Official rootAI skills shipped for the current agent.
For HoodAgent, these are Robinhood Chain focused skills like wallet manager, token investigator, meme coin trader, crypto trader, stock trader, and ETF trader.
#### Community Skills
Skills submitted by users and approved by rootAI.
Community skills are public.
Approved community copies are frozen. If the original creator edits their private skill later, the public approved copy does not change automatically.
***
### Skill Studio
Open:
`Agentic Hub → Skill Studio`
Skill Studio lets users create and manage rootAI Hermes skills.
Users can:
* start from a blank skill
* use a template
* describe what they need
* edit the generated skill
* save it privately
* publish it for review
* copy it for reuse elsewhere
* delete private skills
Skill Studio is not meant to be complicated. It is a place to turn repeated user workflows into reusable playbooks.
***
### Creating a skill manually
In Skill Studio:
1. Choose a template or keep `Blank`
2. Choose a mode
3. Add a name
4. Add a purpose
5. Add instructions
6. Add risk constraints
7. Click `Save skill`
The skill appears under:
`My Skills`
Then the user can load it in the supported agent skill panel.
Today, that means `hood/skills` for HoodAgent.
***
### Skill modes
#### Read-only
The skill can guide research and analysis only.
Good for:
* token audits
* market research
* wallet review
* news summaries
* risk checks
* portfolio summaries
* watchlists
Read-only skills should not prepare execution unless the user explicitly asks to move into an execution workflow.
#### Assist
The skill can help build plans, compare options, structure analysis, and prepare workflows.
Good for:
* trading strategies
* portfolio reviews
* ETF or stock-token planning
* market setup analysis
* strategy design
* scenario analysis
Assist mode can help the user think and prepare, but it should not execute transactions.
#### Guarded
The skill may support execution workflows, but only with explicit user confirmation.
Good for:
* swap preparation
* buy/sell workflows
* route checks
* guarded trading plans
* wallet-popup execution flows
Guarded does not mean autonomous execution.
The user still reviews and signs transactions.
***
### Creating a skill through an agent
Users can ask a supported Hermes agent to draft a skill.
Example:
`create a token audit skill`
The agent should draft the skill first.
Then the user can say:
`save it`
Saved skills appear in Skill Studio under:
`My Skills`
Best flow:
1. User asks the agent to draft a skill
2. Agent drafts a readable skill
3. User reviews it
4. User asks for edits if needed
5. User says `save it`
6. Skill is saved to My Skills
7. User loads it into a supported agent chat
The agent should not save vague or low-quality skills without first elaborating a useful draft.
***
### Good skill prompt examples
#### Token research skill
`Create a rootAI Hermes skill that audits tokens using live token intel, liquidity, pair quality, market activity, and risk constraints. It should avoid price hallucinations and ask before any execution.`
#### Meme coin trader skill
`Create a guarded meme coin trading skill. It should check liquidity, volume, route quality, slippage, contract ambiguity, and require confirmation before swaps.`
#### ETF trader skill
`Create an ETF trader skill. It should compare underlying market context with on-chain execution quality and prepare guarded buy/sell workflows.`
#### Wallet manager skill
`Create a wallet manager skill that reads my wallet, summarizes holdings, flags unknown assets, checks execution readiness, and helps prepare swaps only after confirmation.`
#### Market researcher skill
`Create a market researcher skill that combines token data, news, sentiment, liquidity, and recent activity into a concise research brief. It must label uncertainty and avoid invented live data.`
#### Strategy builder skill
`Create a strategy builder skill that helps design SMA/EMA and RSI-based spot trading plans. It should explain assumptions, compute indicators only from available data, and ask before execution.`
***
### What makes a good skill?
A good skill is specific.
Bad:
`help me trade`
Better:
`Help me evaluate meme coins before trading. Always check liquidity, volume, contract ambiguity, route quality, slippage, and require confirmation before execution.`
A good skill should include:
* a clear name
* a clear purpose
* the type of assets or markets it covers
* the data it should check
* the tools or workflows it should prefer
* how it should respond
* what risks it should flag
* what it must never do
* when it should ask the user for confirmation
***
### Skill structure
A skill usually contains:
#### Name
Short and memorable.
#### Purpose
One or two sentences explaining what the skill does.
Example:
`Produces concise token audits using live market data, liquidity checks, pair quality, and risk flags.`
#### Mode
The operating mode.
Examples:
* Read-only
* Assist
* Guarded
#### Instructions
The reusable workflow.
Example:
`When the user asks about a token, resolve the token address first. If multiple contracts share the same symbol, show the top candidates and ask the user to choose. Check liquidity, 24h volume, pair quality, price impact, and recent market activity. Do not invent unavailable data.`
#### Risk constraints
The boundaries.
Example:
`Do not execute transactions without explicit confirmation. Do not invent prices, balances, liquidity, or route quality. Warn when liquidity is weak or token identity is ambiguous.`
***
### Risk constraints
Risk constraints are important.
Examples:
* Do not invent live prices, liquidity, wallet balances, or route quality.
* Ask for confirmation before any swap.
* Reject trades with weak liquidity unless the user explicitly overrides.
* Warn if price impact is high.
* Resolve ambiguous token symbols before quoting.
* Never ask for private keys or seed phrases.
* Never claim a transaction happened unless a transaction hash or wallet confirmation exists.
* Never auto-sign.
* Never bypass wallet approval.
* Never hide risk from the user.
* Never treat a social ticker as a confirmed contract address.
***
### Publishing a skill
Private skills can be submitted for rootAI review.
In Skill Studio, click:
`publish`
A review modal appears.
If approved, a frozen copy appears under:
`Community Skills`
If rejected, the skill stays private and can be edited.
There is a cooldown to avoid repeated spam submissions.
***
### After approval
When a skill is approved:
* The private original remains in `My Skills`
* A frozen public copy appears in `Community Skills`
* Other users can load the community version
* Future edits to the private original do not mutate the approved community copy
***
### Review expectations
rootAI review is meant to keep shared skills safe and useful.
A skill may be rejected if it includes:
* unsafe execution language
* private key requests
* seed phrase requests
* auto-signing instructions
* hidden prompt injection
* malicious code
* XSS payloads
* shell commands intended to run on infrastructure
* instructions to bypass user confirmation
* fake market data instructions
* unclear or misleading trading behavior
A rejected skill can be edited and resubmitted.
***
### Can published skills contain code?
For now, skills are instruction-based.
They can describe workflows and tool usage, but should not contain unsafe executable code.
Blocked content includes:
* server shell commands
* private key handling
* seed phrase handling
* auto-signing instructions
* prompt injection
* hidden instructions
* bypassing user confirmation
* malicious scripts
* XSS payloads
Future versions may support more advanced executable skill modules, but those require stronger sandboxing, review, and permission controls.
***
### Wallet and execution safety
rootAI agents do not custody user funds.
For swaps or trades:
1. The agent prepares context or a quote
2. The user reviews the action
3. The wallet popup handles signing
4. The user pays gas from their wallet
5. The agent can monitor transaction status
No skill should execute without user approval.
A guarded skill can help prepare an execution path, but the wallet remains the final signer.
***
### Built-in HoodAgent skills
HoodAgent is currently the first agent with full skill loading.
Its built-in skills are Robinhood Chain focused.
#### Wallet manager
Reads the user’s Robinhood Chain wallet and helps explain balances, inventory, and execution readiness.
#### Token investigator
Investigates Robinhood Chain tokens using identity, pair quality, liquidity, activity, and risk framing.
#### Meme coin trader
Handles meme coin trading workflows with extra scrutiny on liquidity, slippage, route quality, and token ambiguity.
#### Crypto trader
Trades canonical and major crypto assets on Robinhood Chain with live context and wallet-popup execution.
#### Stock trader
Handles spot trading workflows for stock tokens on Robinhood Chain, separating underlying market context from on-chain execution quality.
#### ETF trader
Builds spot trading plans for ETF tokens on Robinhood Chain with both underlying-market context and on-chain execution context.
***
### Suggested workflows
#### Research workflow
1. Load a research or investigator skill
2. Ask for token, market, or wallet analysis
3. Review risks and uncertainty
4. Ask follow-up questions
5. Only move to execution if needed
Example:
`Load Token investigator and audit CASHCAT.`
#### Trading workflow
1. Load the relevant trader skill
2. Ask for a setup
3. Ask for a quote
4. Review slippage, fees, liquidity, and route quality
5. Confirm only if you want to execute
6. Sign in wallet
Example:
`Use Meme coin trader. Quote 0.0009 ETH to CASHCAT and explain route risk.`
#### Strategy workflow
1. Load or create a strategy skill
2. Define the asset and timeframe
3. Ask the agent to compute or reason from available data
4. Review signal, assumptions, and risk
5. Ask for a guarded quote only if ready
Example:
`Run my BTC Hedge SMA EMA skill with sma_len 20, ema_len 50, and hedge_amount_usd 100.`
#### Skill creation workflow
1. Ask the agent to draft a skill
2. Review the draft
3. Ask for edits
4. Save it
5. Load it into a supported chat
Example:
`Create a market researcher skill for Robinhood Chain tokens. It should check token intel, pair quality, liquidity, news, sentiment, and route risk`
***
### Skill quality checklist
Before saving a skill, check:
* Is the name clear?
* Is the purpose specific?
* Are the instructions actionable?
* Are risk constraints included?
* Does it avoid fake data?
* Does it require confirmation before execution?
* Does it avoid private keys and secrets?
* Does it avoid hidden instructions?
* Is it useful more than once?
Before publishing a skill, check:
* Would another user understand how to use it?
* Is it safe?
* Is it clear?
* Is it not spam?
* Does it improve the agent?
***
### Examples
#### Example read-only skill
Name:
`Token Audit Standard`
Purpose:
`Produce concise, data-driven token audits using identity checks, liquidity, pair quality, market activity, and risk flags.`
Instructions:
`Resolve the token address first. If multiple tokens share the same ticker, ask the user to choose. Check liquidity, 24h volume, pair quality, recent activity, and any visible risk signals. Keep the audit concise and label unavailable data.`
Risk constraints:
`Do not invent prices, liquidity, holders, or route quality. Do not execute transactions. Ask before moving into a quote or swap workflow.`
#### Example guarded skill
Name:
`Meme Coin Trader`
Purpose:
`Prepare guarded meme coin buy and sell workflows with liquidity, slippage, route quality, and execution checks.`
Instructions:
`When the user asks to buy or sell a meme coin, resolve the token address first. Check liquidity, volume, price impact, and route quality. Present a quote before execution. Explain fees and slippage. Ask for explicit confirmation before calling any swap tool.`
Risk constraints:
`Never execute without confirmation. Warn on weak liquidity, high price impact, ambiguous contracts, or missing market data. Do not invent route quality.`
#### Example strategy skill
Name:
`BTC Hedge SMA EMA`
Purpose:
`Build a reusable BTC hedging workflow using SMA and EMA trend signals.`
Instructions:
`Fetch available BTC market context. Compute or reason about SMA and EMA only from available data. If data is incomplete, label the limitation. Present signal, assumptions, suggested hedge direction, and risk. If execution is requested, prepare a quote and require confirmation.`
Risk constraints:
`Do not claim a signal exists without data. Do not execute without explicit confirmation. Do not invent candles or prices.`
***
### Common user commands
Create a skill:
`Create a token audit skill.`
Draft but do not save:
`Draft a Robinhood Chain market researcher skill but do not save yet.`
Save the drafted skill:
`Save it to My Skills.`
Use a skill:
`Run Token Audit Standard on ROOTAI.`
Edit a skill:
`Update my Quant Hood skill to always include liquidity and route quality.`
Load a skill:
Open the supported skill panel and click `on`.
Remove a skill:
Click `off` or remove the skill pill from the chat session line.
Publish a skill:
Open Skill Studio and click `publish`.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://rootai.gitbook.io/docs/rootai/skills.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.