skill

interface SkillResource {

Named resource bundled with a skill.

When a skill is loaded, every resource is resolved and appended to the skill's instructions under a ## Resources heading, each as its own ### name section. Because resolution only happens at load time, resources are a good place for large reference material that should not weigh on the agent until the skill is actually needed.

import { skill } from 'fino:ai/skill';

const research = skill({
  name: 'research',
  description: 'Research briefing workflow.',
  instructions: 'Summarize the brief before proposing next steps.',
  resources: [
    { name: 'style.md', content: '# Style\nWrite in plain language.' },
    {
      name: 'brief.md',
      content: async () => (await fetch('https://example.com/brief.md')).text(),
    },
  ],
});

Properties

interface Skill {

Lazy-loadable agent capability.

Only name and description are surfaced to an agent up front (via the registry manifest); instructions, resources, and tools stay dormant until the skill is loaded. Construct skills with skill() rather than implementing this interface by hand — remote skills carry internal state that only skill() wires up.

import { skill, skillRegistry } from 'fino:ai/skill';
import type { Skill } from 'fino:ai/skill';

const reviewer: Skill = skill({
  name: 'review',
  description: 'Code-review checklist and tone.',
  instructions: async () => 'Point out risky changes before style nits.',
});

const registry = skillRegistry([reviewer]);

Readonly Properties

interface SkillsMdOptions {

Options for SkillsMD-backed remote skills.

All fields are optional; the defaults talk to the public SkillsMD API with the global fetch and a five-minute instruction cache.

import { skill } from 'fino:ai/skill';

const remote = skill({
  repo: 'acme/support-writing',
  skillsmd: {
    apiBaseUrl: 'https://skillsmd.internal/api',
    cacheTtlMs: 60_000,
  },
});

Properties

interface SkillRegistry {

Registry of skills available to an agent.

Pass a registry as skills when constructing an agent: the agent puts manifest() in its system prompt, registers asLoaderTool() so the model can pull skills in on demand, and calls load() to re-register bundled tools for any load_skill calls it finds in resumed message history.

Load results are cached per registry. Local skills are cached for the registry's lifetime; remote skills expire after their configured TTL. Concurrent loads of the same skill share one in-flight promise, and a failed load is evicted so the next attempt retries from scratch.

import { skill, skillRegistry } from 'fino:ai/skill';

const registry = skillRegistry()
  .add(skill({
    name: 'billing',
    description: 'Refund and invoice policies.',
    instructions: 'Never promise a refund without an order id.',
  }))
  .add(skill({ repo: 'acme/support-writing' }));

registry.manifest(); // [{ name: 'billing', ... }, { name: 'support-writing', ... }]
const { instructions, tools } = await registry.load('billing');

Methods

interface LocalSkillDefinition {

Local skill definition accepted by skill().

Everything about a local skill is supplied in code: metadata, instructions (inline or lazy), and optionally executable tools and resources.

import { skill } from 'fino:ai/skill';
import { tool } from 'fino:ai/tool';
import { v } from 'fino:validate';

const deploys = skill({
  name: 'deploys',
  description: 'Rollout and rollback procedures.',
  instructions: 'Check the error budget before any rollout.',
  tools: {
    rollback: tool({
      name: 'rollback',
      description: 'Roll a service back to the previous release.',
      parameters: v.object({ service: v.string() }),
      execute: async ({ service }) => `rolled back ${service}`,
    }),
  },
});

Properties

interface RemoteSkillDefinition {

SkillsMD-backed remote skill definition accepted by skill().

Only repo is required. The skill appears in the registry manifest immediately with placeholder metadata and fetches the repository's skill markdown on first load. Instructions are the markdown body below the YAML frontmatter; remote skills never carry executable tools or resources.

import { skill } from 'fino:ai/skill';

const remote = skill({
  repo: 'acme/support-writing',
  description: 'House style for support replies.',
});

Properties

function skill(def: LocalSkillDefinition | RemoteSkillDefinition): Skill

Create a skill definition.

A definition with a repo field builds a remote SkillsMD skill; anything else is a local skill. Local skills are returned essentially as given, with tools and resources defaulting to empty. Remote skills defer all network work to load time: loading queries the SkillsMD API, falls back to the repository's skill.md/SKILL.md via the GitHub contents API, then to a README with frontmatter, and rejects if no frontmattered markdown is found anywhere.

Throws immediately if a remote repo is not a bare owner/repo identifier.

import { skill } from 'fino:ai/skill';

const local = skill({
  name: 'triage',
  description: 'Incident triage steps.',
  instructions: async () => 'Page the on-call before mitigating.',
});

const remote = skill({ repo: 'acme/incident-runbooks' });

function skillRegistry(skills?: Skill[]): SkillRegistry

Create a registry of skills that an agent can load on demand.

The optional initial list can be extended later with add(). Local and remote skills mix freely in one registry and load through the same load_skill tool.

import { agent } from 'fino:ai/agent';
import { openai } from 'fino:ai/model';
import { skill, skillRegistry } from 'fino:ai/skill';

const registry = skillRegistry([
  skill({
    name: 'billing',
    description: 'Refund and invoice policies.',
    instructions: 'Never promise a refund without an order id.',
  }),
]);

const bot = agent({ model: openai({ model: 'gpt-4o' }), skills: registry });