Skills

When you ask an agent to set up a webhook, analyze a dataset, or build a dashboard, it doesn't wing it. It loads a skill — a focused knowledge module that tells it exactly how to approach that specific type of work.

Skills are how Obvious agents go from general-purpose to genuinely good at particular tasks.

What a skill actually is

A skill is a package of instructions, workflows, and reference material scoped to a specific domain. Think of it like specialized training modules — the agent loads one when it needs a capability, uses it for the duration of the task, and unloads it when the work is done.

Each skill contains:

• A core guide — the essential workflow and decision-making logic the agent follows. This stays in the agent's active context the entire time the skill is loaded.
• Detailed reference material — deeper documentation, templates, code snippets, and examples the agent can pull from as needed.
• Triggers — keywords and phrases that tell the agent when this skill is relevant. Mention "webhook" in a conversation, and the agent knows to reach for the webhooks skill before it starts working.

The key design choice: skills are loaded on demand, not all at once. An agent working on a data import doesn't need the folio-building skill taking up space in its context. It loads what it needs, when it needs it.

How agents discover and load skills

When a conversation starts, the agent can see a list of every skill available to it — names, descriptions, and triggers. It's a lightweight index, not the full content. The agent scans this list against what you're asking for, and when it finds a match, it loads the relevant skill into its active context.

Loading a skill means the core guide becomes part of the agent's working knowledge for every turn of the conversation. It doesn't fade into the background like a file the agent read once. It stays front and center, shaping how the agent thinks about each step.

The agent can also unload skills when they're no longer relevant. Finished building that dashboard? The visualization skill gets unloaded, freeing up context space for whatever comes next.

This matters because agents have limited context — the amount of information they can hold and reason about at once. Skills let agents be deeply knowledgeable about the task at hand without being shallow about everything simultaneously.

Built-in skills

Obvious ships with built-in skills maintained by the team. These cover core capabilities:

• Web hosting — how to build and deploy interactive apps from the sandbox.
• Folio builder — creating editorial-quality web presentations.
• Data visualization — charting best practices, color palettes, and Plotly patterns.
• Writing — voice, structure, and quality standards for document creation.

Built-in skills are available to every agent automatically. They're versioned and updated as the product evolves, so the agent's knowledge stays current without you doing anything.

Some built-in skills are gated behind feature flags, meaning they only appear when a specific capability is enabled for your workspace. You won't see skills for features you don't have access to.

Custom skills

Built-in skills handle common workflows. Custom skills handle yours.

Custom skills are created by you (or by an agent on your behalf) to capture specialized knowledge specific to your work. An API integration you use weekly. A data cleaning workflow with particular business rules. A reporting format your team standardized on.

Custom skills follow the same structure as built-in skills — triggers, core guide, reference material — but they're scoped to your workspace. They show up alongside built-in skills in the agent's index, and the agent loads them the same way.

The practical effect: the more custom skills you build, the less you repeat yourself. Instead of re-explaining your CRM data model every time you ask for pipeline analysis, the agent loads the skill that already knows the schema, the field mappings, and your team's definitions.

The skill builder

You don't need to write skill files by hand. The skill builder is an agent-assisted workflow that turns a description of what you want into a production-ready skill.

Here's how it works: you describe the workflow — what the skill should do, what steps are involved, what triggers should activate it. The agent takes that input, researches the domain, designs the skill structure, writes the documentation, tests any scripts, and validates the result.

The skill builder works in a dedicated mode. The agent researches current best practices (not just its training data), creates properly structured files, tests code before including it, and validates everything before marking the skill complete. You review the output and iterate if needed.

Once built, the skill is immediately available. Next time you — or any agent in your workspace — encounter a matching task, the skill loads automatically.

When skills matter most

Skills shine in two situations. First, when a task has a specific right way to do it — an API with particular authentication patterns, a data format with known gotchas, a workflow with steps that need to happen in order. Skills encode that procedural knowledge so the agent doesn't have to figure it out fresh each time.

Second, when consistency matters. If three different agents across three different projects need to generate reports in the same format, a skill ensures they all follow the same structure and standards. No drift, no "well, this agent does it slightly differently."

The underlying principle: agents should get better at your work the more you use them. Skills are the mechanism that makes that happen.

---

Next steps

• Memory — How agents retain context between conversations.
• Custom Modes — Tailor agent behavior with personalized instructions and model selection.
• Key Concepts — How projects, workbooks, and agents fit together.