Skip to content
theo home
Sign inStart building
theoSkillsyour intelligence layer

The way you work.
Made reusable.

A skill tells theo how to work: your instructions, knowledge, and permitted tools. Built-in MCIR memory adds relevant history. Reuse the combination across your models, agents, and connected apps.

build your first skilltry attaching a sample skill
service-reviewcustom skill
YOUR TEAM’S KNOW-HOW, PACKAGED

Your architecture.
Built into the review.

A specialist that works from your service’s design decisions and operating rules, not just general coding knowledge.

Instructions
Apply retry rules. Cite the source. Flag missing context.
Knowledge
Architecture decisions + the current runbook
Tools & access
Read the permitted service spec. No deployment access.
Return a cited review. Leave approval to a person.
Authored example. No skill is installed or run on this page.

01more than a saved prompt

Give your expertise a structure.

Instructions

Define the job.

Describe what good work looks like: the task, the tone, the expected response, and what to leave unanswered. A prompt extension supplies reusable guidance.

Knowledge

Bring the reference.

Attach the material the skill needs, from a handbook to a product guide. Keep ownership, freshness, and appropriate access in view as the material changes.

Tools + permissions

Declare the access.

Define the callable operations and the permissions they need. Your integration still owns the authorized handlers; a tool description is not an implementation.

Preferences + triggers

Choose the fit.

Set a model preference or a trigger for the skill’s job. These choices participate in the wider routing configuration, rather than replacing it.

02two ways to build

Start on a canvas. Or in your editor.

Compose it visually.

Use Studio’s E.V.I. Canvas to connect instructions, models, knowledge, and tools. Save the composition, compile its structure, and test with mock data before publishing.

  1. Input
  2. Prompt
  3. Model
  4. Output
A skill-building canvas, not a request-routing graph.explore Studio + E.V.I. Canvas

Define it in code.

Edit a skill manifest or use defineSkill() in the SDK. The authoring guide covers scaffolding, validation, and publication. Keep the package and its changes reviewable alongside your application.

read the skill-building guide (opens in a new tab)
release-brief.ts · skill authoringexample
import { defineSkill } from "@hitheo/sdk";

export default defineSkill({
  name: "Release Brief",
  slug: "release-brief",
  version: "1.0.0",
  description: "Source-linked release drafts",
  category: "automation",
  author: { name: "Your team" },
  systemPromptExtension:
    "Draft from approved notes. Cite sources. Flag gaps.",
  tools: [],
  permissions: ["read:artifacts"],
  trigger: {
    type: "keyword",
    config: { keywords: ["release", "changelog"] }
  }
});
An example using documented SDK fields. No tool is declared here and nothing executes on this page. Add your reference knowledge and authorized handlers as the skill develops.

03a small, repeatable development loop

Build. Test. Attach. Inspect.

  1. 01

    Write one clear job

    Start with the release brief: produce a source-linked draft from approved notes. Define the expected result and who will review it.
  2. 02

    Add the minimum context and access

    Choose the knowledge and tools the job actually requires. Keep a read-only scope until there is a specific need for an external action.
  3. 03

    Validate and test the gaps

    Compile the canvas or validate the manifest. Test synthetic examples with missing references, denied tools, and ambiguous requests. Mock tests do not replace integration tests.
  4. 04

    Attach the skill to the work

    Install it for use in the product, or select its slug for a request through the documented API. In the orchestrator, skills attach to model nodes.
  5. 05

    Inspect and refine

    Review the resulting behavior and the effective combination of skills, routing, and policy. Change one part, then rerun the same fixtures.
try the skill tray in the workbenchconnect it to your application

04choose the audience

Keep it yours. Share it deliberately.

one intelligence layer, distinct jobs

The skill is part of the system.

Skills define the know-how.

Reusable instructions, knowledge, and tools give a model a job-specific starting point.

explore skills on desktop

Routing chooses the path.

Rules and examples guide the capability selection. They do not grant new permissions.

open Routing Studio’s guide

Guardrails apply checks.

Configure input/output policies and bind them to the intended key. A persona is not policy enforcement.

explore Guardrails
How is a skill different from MCIR memory?

A skill defines reusable know-how and allowed capabilities. Supported memory paths can supply relevant prior work; full MCIR intent assembly and Memory Chain require separate activation. They meet within the authenticated owner’s scope. Sharing a skill does not share someone else’s memory or permissions.

Is a skill the same as an assistant?

No. An E.V.I. is an assistant with a persona and selected capabilities. Skills are reusable packages you can compose into that assistant or select for a request.

Does creating a skill run its tools?

No. Definitions describe operations. Authorized execution, input validation, and failure handling belong in the real integration. This page creates no accounts, installs no packages, and runs no tools.

your next experiment

Build the intelligence your work needs.

Start with one skill and your choice of models. MCIR memory is built in, so relevant context can continue as you deploy into agents and connected applications.

open the skill builderbuild with the SDK (opens in a new tab)