HasteKit SDK

description: Write a release changelog entry. Use whenever the user asks for release notes.

Group the changes under Added, Changed, Fixed, and Removed... The full house style is in references/style.md.

Point the agent at that folder:

agent := hastekit.NewAgent(&hastekit.AgentConfig{ Name: "Release_Agent", Instruction: hastekit.NewPrompt( "You help maintain this project's releases.", prompts.WithResolver(prompts.DefaultResolvers()...), // ResolveSkills lists them ), Skills: registry, LLM: model, })

The agent lists the skills in its prompt and adds the tool that reads them to its own tools, so a prompt can never advertise a skill the model has no way to open. A prompt runs only the resolvers it is given, so one that leaves out `ResolveSkills` gets a model that never hears about them — see [Prompt resolvers](#prompt-resolvers) below.

The prompt carries only each skill's name and description. The model calls `read_skill` with a name to pull in the instructions, and `read_skill` with a `file` to pull in one of the bundled files — so a long skill costs context only on the turns it is actually used.

Pass several directories to draw from more than one library — a shared set plus this agent's own, say:

Reading happens once, at construction. To pick up edits on disk, build a new registry.

#### Shipping skills inside the binary

Where the skills are part of the program rather than of its deployment, `go:embed` puts the whole tree in the binary — no folder to mount, copy, or keep in sync:

registry, err := hastekit.NewSkillRegistry(skillsFS)

Embedding the parent folder is enough: a skill is found wherever a `SKILL.md` sits, so there is no `fs.Sub` to get right. `NewSkillRegistry` takes any `fs.FS`, so this is also the hook for skills that come from somewhere else entirely.

#### Rules

The name comes from the frontmatter, or from the folder when the frontmatter omits it. A folder holding a `SKILL.md` is one skill, and everything below it belongs to that skill — so a `SKILL.md` bundled as an example or a template stays a bundled file rather than becoming a second, half-formed skill.

Loading fails loudly on a skill with no description, on broken frontmatter, on a directory that isn't there, and on the same name defined twice. Skills decide how the agent behaves, so a bad one should stop startup rather than go quietly missing at runtime.

Only files a skill actually bundles are reachable through the tool: a path that tries to traverse out of the skill folder is refused, so one skill cannot read another or the rest of the filesystem the skills were read from.

Skills work the same under the Temporal and Restate runtimes: the durable agent registers and wraps the reader tool along with the rest, so a `read_skill` call is journaled like any other tool call and replays from the journal rather than re-reading the folder.

#### Skills from somewhere else

`AgentConfig.Skills` takes an `agents.SkillProvider` — a source that lists its skills, supplies the tool that reads them, and introduces them to the model:

The agent asks the source for all three, which is what keeps the prompt and the tools in step. `SkillHint` is the whole of the section's prose and goes in verbatim — the resolver writes the `## Skills` heading and the catalogue, nothing else. Only the provider can write that hint honestly: a `SkillRegistry` names its own `read_skill` tool, while a host serving skills its own way names whatever the model actually has. Say nothing and the model gets the bare catalogue, which beats a prompt naming a tool the agent does not have.

A source that returns no tool is one the model can already reach. `agents.SkillList` lists such skills and adds nothing:

`agents.SkillsWithHint` is the same, plus the prose — for a host that serves skill files through a tool of its own:

#### Prompt resolvers

The system prompt is built by a chain of resolvers, each handed what the last produced along with the run's dependencies:

A prompt starts with an empty chain and is used exactly as written — nothing appended, no templating. `prompts.DefaultResolvers()` is the standard set: `ResolveSkills`, `ResolveHandoffs`, `ResolveDeferredTools`, `ResolveTemplate` — the sections the agent contributes, then the `{{ placeholder }}` pass over the whole thing. Pass what you want, in the order you want; repeated calls accumulate:

Features

• 🔄 Multi-Provider Support - Unified API for OpenAI, Anthropic, Gemini, and more
• 🤖 Agent SDK - Build sophisticated AI agents with tools, memory, and multi-step reasoning
• 👤 Human-in-the-Loop - Integrate human feedback and approval workflows
• 🛡️ Durable Execution - Create fault-tolerant agents with Restate or Temporal
• 🔧 Tool Calling - Function calling and MCP (Model Context Protocol) tool integration
• 🪝 Hooks - Intercept tool calls and model calls for auth, budgets, and audit
• 🏷️ Tool Annotations - MCP-style behavioural hints on both MCP and function tools
• 💾 Conversation History - Maintain context across interactions with built-in persistence
• 🧩 Sub-Agents & Handoffs - Call a specialist as a tool, or transfer the conversation to it
• 🎚️ Steering - Send a correction into a run already in flight
• 🌊 Streaming Support - Real-time streaming responses for better UX
• 🛑 Cancellation - Stop in-flight runs cleanly, including mid-stream and mid-tool-call
• 📝 Structured Output - JSON schema validation for reliable structured responses