A skill is one markdown file that teaches AI agents how to use your protocol, always inside the limits their owner sets. Submit one, and every agent connected to Altana can find it and act on it. The whole process is a pull request.
Step 1. Get the file written
Two ways to produce the same thing: one SKILL.md.
Let your agent write itFastest
Paste this into Claude, Cursor, or any coding agent, with your protocol's name filled in. It reads our template and a finished example, writes the skill, and tests it.
Read the Altana skill template at https://github.com/altananetwork/skills/blob/main/skills/_template/SKILL.md and the example at https://github.com/altananetwork/skills/blob/main/skills/pancakeswap-trading/SKILL.md. Write a SKILL.md for <protocol> following the template exactly: one capability, checksummed addresses in a table, plays with parameters and Typical time lines, and explicit guards. Then write the test scenario described in tools/skill-test/scenarios and self-test with the harness.
Write it yourself
Copy the annotated template and fill in your protocol's addresses, quirks, and plays. See a finished skill for what good looks like. Then check your work with the repo's test harness; it has real agents exercise the skill on a private copy of the chain:
cd tools/skill-test && bun install && bun run skill-test --skill ../../skills/<your-skill-id> --trials 3
View the template
---
name: your-skill-id
description: One sentence saying what the skill does for the user, starting with a verb. Mention the protocol and the chain.
---
# Your Skill Name
One short paragraph: what this skill lets an agent do, and the one rule of the house:
onchain writes go only through the Altana session executor; reads can go directly
against the RPC. If the skill is research only, say the session permits no onchain
calls at all.
## Reference
Facts an agent needs to act correctly. Keep it tight; the agent already knows DeFi
generally. Cover only what is protocol specific.
### Addresses (chain name)
| Contract | Address |
|---|---|
| Main contract the plays call | `0xChecksummedAddress` |
| Token or helper it needs | `0xChecksummedAddress` |
Every address checksummed (run `cast to-check-sum-address`). Only list contracts the
plays actually touch; the session scope is derived from this table.
### Quirks that cause mistakes
- The three to six protocol facts that break naive integrations: decimals surprises,
approve-before-call patterns, functions that return error codes instead of
reverting, timing windows, fee-on-transfer behavior. One line each.
### Functions (if the protocol is unusual)
Signatures for the calls the plays make, only when the agent is unlikely to know them.
## Playbook
One `### Play:` per common action. Two to five plays. Each play: parameters, a
Typical time line, and numbered steps an agent can execute in one script.
### Play: action-name
What it does in one line. Parameters: the two or three things the user chooses.
**Typical time:** ~15s
1. The read that sizes or quotes the action.
2. The `execute([...])` calls, in order.
3. The onchain verification before reporting success.
## Guards (do not remove)
- The safety decisions pinned in place: minimum output floors, balance verification
after every state change, retry limits, stop conditions.
- Always verify outcomes from chain state, never from transaction success alone.
- What the agent must do when something fails: stop and report, never improvise
outside the session scope.
Step 2. Open the pull request
Add your skill directory to the repo and open a PR. Here is what happens next:
1We review it like code: one capability per skill, guards in every play, checksummed addresses, a test scenario included.
2We run the same fork test on our infrastructure.
3On a pass it goes live on this shelf, and every agent connected to Altana can use it.
