In one paragraph

Claude Skills is the skills/<name>/SKILL.md shape Anthropic ships with Claude Code and the API. It’s a strict subset of what a Theseus agent contains, so if you’ve written skills before, the files work inside a Theseus agent without edits. What you get on top is the runtime: the agent holds its own key, its own seus balance, and its own state, and every output is signed and indexable at /poa/<agentId>.

When to use which

Stay on Claude Skills if

Your agent runs inside a single Claude Code session and the audit trail is the chat transcript.
You need nothing more than skill activation and tool calling inside one user session.
Your tools and skills are private and the signature on the output is not interesting to a third party.

Move to Theseus if

A third party needs to verify that the agent actually produced the output (oracle feeds, governance reviews, bug-bounty triage, content credentials).
The agent must persist between sessions without you wiring a database.
Multiple agents call each other and the chain of trust has to be machine-checkable.
The agent owns assets, signs transactions, or operates unattended on a schedule.

Side by side

Concern	Claude Skills	Theseus	Diff
Skill file shape	skills/<name>/SKILL.md with frontmatter (name, description, allowed-tools)	Identical. Theseus parses the exact same shape.	same
Skill activation	Model decides based on the description, or always-on if specified	Same model. Plus an explicit auto-activate: true frontmatter key for skills that should always be in context.	same
Tool surface	Declared per-call in Claude API tools array, or per-conversation in Claude Code config	Declared once in tools.yaml at the workspace root. Native, common, and BYO blocks. Compiled into the agent at deploy time.	extended
System prompt	Conversation-scoped. Passed in each request.	Stored in THESEUS.md at the workspace root. Compiled into the agent at deploy time. One source of truth.	extended
Identity	None. The skill runs inside whatever session you set up.	Each agent has its own keypair generated at registration. Every output signed by that key.	new
State across runs	None. You wire your own database or context store.	Persisted on chain. Memory, run history, and tool-call receipts available without external infrastructure.	new
Audit trail	Whatever logging you instrument client-side.	Free. The credential at /poa/<agentId> is a verifiable record of every signed decision.	new
Multi-agent composition	You orchestrate via your own dispatcher	Sub-agents are called the same way as tools. The receiving agent signs its own response.	extended
Verification of outputs	Trust the session that ran the skill	Anyone can verify a signed output offline against the public JWKS.	new
Authoring complexity	Frontmatter + markdown	Same. One extra YAML file for the tool catalog, one for the agent prompt.	same

Bringing an existing Claude Skill to Theseus

Three steps. Each one is one file.

1. Drop the SKILL.md unchanged

The same file you ship in a Claude Code project goes under skills/<name>/SKILL.md in the Theseus workspace. No edits required.

2. Write THESEUS.md

The system prompt for the agent goes here. If you previously kept the prompt in your Claude Code session config or your client code, paste it into the body of THESEUS.md with the YAML frontmatter:

THESEUS.md

---
name: My Agent
id: my-agent-v1
model: claude-sonnet-4-6
---

<paste your existing system prompt here>

3. Move the tool declarations into tools.yaml

Whatever tools your skill calls go in tools.yaml. If you were already passing them in the Claude API tools array, the JSON Schemas are identical:

tools.yaml

native-tools: []

byo-tools:
  my_tool:
    description: Same description you used in the Claude API tools array.
    parameters:
      type: object
      properties:
        # ... your existing JSON Schema, unchanged
      required: [...]
    auto-activate: true

Add the generic agent.rs (copy from any of the 14 reference agents; identical across all of them) and deploy via the playground or CLI.

What you get on the other side

Every output is signed by the agent’s own key. Anyone consuming the result can check it against the JWKS at theseus.network/poa/.well-known/jwks.json.
The agent gets a credential page at /poa/<agentId> showing the four-file workspace, recent run grade, registered capability surface, and the current signed credential.
State carries between runs without you setting up Redis or Postgres. The runtime persists it on chain.
Sub-agent calls work like tool calls. The agent you call signs its own response, and you can trace the receipts back through the chain.
Auditors don’t ask you for screenshots. Every signed decision is on the credential page, permanently.

Where Claude Skills wins

No infrastructure. Claude Code runs the skill in the same session you’re coding in. For interactive personal use, that’s the right shape.
Faster turnarounds. The skill runs in the same session as the model call. Theseus adds the chain’s queue-prove-resume cycle to anything that holds value on chain.
Source-file privacy. The skill body and tool calls stay inside your Anthropic session. A Theseus agent’s files render publicly at the credential page.

If the agent identity, persistence, and signed receipts don’t matter for what you’re building, Claude Skills is enough. Theseus is for the case where they do.

Theseus vs Claude Skills