Skip to content
Describes how WilsonOS is designed to work.What works today →

Capabilities

Pillar 03 · Capabilities

Skills are know-how, workflows chain them into outcomes, and connections are what an agent can reach. Trust belongs to the skill, not the agent.

Everything your agents can do, in one list you can grow. A capability is a written method for one job, a skill, or a sequence of skills that reaches an outcome, a workflow. Your agents pick the right one for the work, say which they chose, and get better at it as you rate what it makes. Adding a capability does not mean waiting for a new version of the app: it is a new entry in the list.

Capabilities6 shown · pick one
NameKindCategory
Mminute-mystery-writerSkillContent writing
PpinterestSkillSocial publishing
Yyoutube-thumbnailSkillImage and design
Aamazon-a-plus-contentSkillBook publishing
Rmarket-research-briefWorkflowResearch
Llinkedin-profile-rewriterSkillCareer
Add a capability

Three ways a new one arrives

  1. Import it. Bring in a skill from a library or another tool. It is read and analysed first, staged, and joins the list only when you accept it.
  2. Build it with your agent. Describe a job you repeat; the agent writes the method down as a skill, and you rate its first outputs.
  3. Let the agent propose it. When nothing in the list fits, the agent says so instead of improvising, and drafts one for you to approve.
M

minute-mystery-writer

Writes short mysteries a child can solve from the page

skillcontent writingversion 49.7.2
Runs from
Chat, or a batch the agent schedules
Checks
A cold solve, a fair-play check and a child-reader check before you read anything
Got better by
Five batches, each failure written into the next version
You see it in
The Workbench, one story per version

Walkthrough: a skill getting better.

A labelled illustration of the idea, not the app's screen. The names are real skills and workflows from the catalogue of about 230 skills and 30 workflows; pick a row to see its card.
1

You ask in chat

Say what you want. The agent picks the skill, says which, and does the work. This is how most work starts today.

2

You press a button

Screens that know the job put it one click away: Run skill in an engine, a mini-app in the Studio, a quick action on Mission Control.

3

A schedule runs it

A routine fires on its own clock, a weekly batch of pins or a nightly data pull, and reports to the conversation you chose.

Engines are where all three meet. In a channel engine some capabilities pull data in on a schedule, some move the work along when you press a button, and some you start in chat, and together they carry the work around one loop:

Signals→Ideas→Plan→Create→Publish→Measure

The agent is involved at every step, and you approve what moves forward. See Engines.

A capability is improved on evidence, not on a good day. Your ratings are credited to the skill that made each output. When a better method is proposed, the Showdown runs the current version and the candidate on the same brief, scores both on criteria written down first, lists anything the candidate does worse, and leaves the promotion to you. See Getting sharper.

Reaching outside tools — and seeing it all here

Section titled “Reaching outside tools — and seeing it all here”

Connecting a service widens what your agents can do: a store, a social account, an advertising account, an image or video model, your email. The work still comes back to WilsonOS, so whichever tool made it, you see it, compare it and approve it in the same place. Seeing the output is half of what the workspace is for; see Your workspace.

A skill is an instruction the agent reads just before doing the job, plus any reference material and deterministic tools it needs. The instruction says what good looks like and how to get there; the tools do the parts an agent should not improvise, like calling an image generator or a publishing platform. Three properties matter:

  • Atomic. One skill, one job: write a hook, render a brand book, pull customer phrases out of reviews. A skill that does five things is five skills in a coat.
  • Brand-agnostic. The same skill serves every brand and loads the brand’s context when it runs, which is why one improvement lifts every brand’s work.
  • Declares what it needs up front. Its first step names exactly the context to load, so nothing loads “in case” and each piece loads once per task.

Skills live in one catalogue of a few hundred, grouped by category and job. Open one and you see every output it made, the rating each received, its cost, and its trend.

The rating is credited to the recipe, per dish. The link that matters is skill → output, not skill → task.

Skill
the recipe
chosen for the task, and named out loud
Run
one go at it
with a receipt: what it called, what it cost
Version
the dish
the exact file it made
Your rating
on that version
credited back to the skill that made it
A labelled diagram, not a screenshot. A task that ran nine skills and scored “3” teaches nothing; “this thumbnail is weak” credited to the thumbnail skill is a signal it can improve on.

Two records are kept apart: the plan (which skills the agent considered and why) and the fact (which skill actually made this file). Ratings ride the fact, never the plan.

Mastery and judgement. The skill says what good looks like; the agent decides how the brand bends the method for this piece of work, and says so. When they conflict — the skill says lead with the keyword, the brand says lead with the reader’s problem — the brand wins and the agent records that it deviated and why. A good result because the method is good is evidence for the skill; a good result because the agent bent the method well is evidence for a change to it, proposed and tested. What an agent never does is quietly rewrite a skill because one output went well. Upgrades are proven in Skill Showdown first.

Left to itself, a capable agent reaches an outcome a different way every time. That is fine for a one-off and corrosive for a business: you cannot improve a process you cannot repeat, or trust guardrails the agent has to remember. A workflow makes the path explicit — steps, inputs, outputs, which skill each step calls, where a person decides — so it can be repeated, rated and improved. When your request matches a workflow, the workflow is the plan; work that matches none gets a plan written first.

Every workflow meets three requirements:

  1. Announce as you go. At each step the agent says which skill it is running, which is what makes the progress trail in a conversation possible.
  2. Hard gates first. A labelled block of rules near the top that beats any other instruction or “auto” mode.
  3. A cost gate on every paid step. Quote the model, size, quantity and expected cost; ask; stop and wait for an explicit “go”. “Do all of them” is not a “go” — the agent re-quotes at the new scope and waits again, and approval for one run never covers the next. The gate is repeated inside the paid skill itself, so calling the skill alone is safe too.

A workflow names the points where a person must decide before work starts, so they arrive as expected questions rather than interruptions. It runs from chat, from a schedule, or from an engine’s proposal, and every run records what it started, which skills it ran, what it made and what it cost. Workflows are shared by every brand, so a new one or a change to one is confirmed with the owner.

Every image, video and audio render goes through a single door. Skills call the door; nothing calls a provider directly. The door applies the brand’s references, names the skill making the render, enforces spend limits — refusing, with a reason, rather than silently switching provider — and writes a receipt.

The receipt is opened when the job is submitted and closed when the result arrives, because everything it needs except the outcome is known at submit. A killed process or a ten-minute clip that finishes after the agent moved on never loses the record of a render that was already paid for. Edits (an audio swap, captions, a compressed preview) and files made elsewhere or uploaded by hand are registered too: nothing leaves the pipeline unregistered. That rule comes from a real loss — an approved trailer was an edit that never entered the registry, the local copy was cleaned up, and the only durable file left was the wrong version.

What it makes answerable: what did this task cost (sum the receipts), which skill earns stars and which burns spend (receipts joined to ratings), and where did this image come from (prompt, references, model, skill, run).

A business does not live inside one app. A connection is a named link to an outside service, and each one declares its account and brand scope, its permissions, what it can read, and what it can do — so “what can Scout actually do on Pinterest?” has a written answer.

Five kinds of connection, all reached through the same rules.

Two rules make it safe to let an agent act out there. Same operations, two interfaces: a person clicks Publish, an agent calls a tool, and both go through the same service and the same permission checks — exposing something to agents never creates a weaker second path. One door per capability, and the key stays behind it: an agent never holds a provider’s real credential. It presents a short-lived pass to the door; the door checks the scope, adds the real key, makes the call, and records it against the run.

A connection is not a source of truth (your records stay canonical), not a licence (it publishes only a version a person approved), and not brand-blind (every action carries the brand it was taken for).

Four layers are meant to change per business: skills, workflows, brand context and connections. The fifth — new kinds of business record, with their own permissions and screens — is deliberate integration work: a legal matter or an inventory item is not a product or a campaign, and industry support is not created by adding a prompt. Underneath, three things never change: the agent loop, the foundations, and the meaning of the shared record names.

For builders — doors, grants and new data
  • A connection is data, not a deployment. Adding one is a registry entry — account, scope, reads, actions, and the door that routes it. Nothing is rebuilt.
  • A grant is separate from the connection. The connection says what is possible with that account; the grant says which agents, in which brands, may use it. Revoking a grant takes effect on the next turn, because the tool list is assembled per turn from the grants the runtime’s pass carries.
  • Remote tools versus local tools. A tool reached through a door is the default: the door holds the credential and writes the receipt. A tool that runs alongside the runtime has no door in between, so it never gets a real credential and is reserved for work on the runtime’s own files. When both exist, the routed one wins.
  • Asset identity. A media asset has a stable id; its bytes are stored once by content hash with a primary copy and a backup; a name or path is a label that can change. Every route that serves bytes checks brand access first.
  • A new data source is not trusted on arrival. It is received with its provenance and retention, mapped onto the shared business records, has its own fields kept in structured extensions, and gets dedicated tables only when new relationships or reporting justify them. Metric definitions and identity matching across sources are integration work with an owner, never a side effect of switching a connector on.
  • Why routing is prescribed. An audit of ad-hoc scripts found a large share calling providers directly; each was a render with no receipt, a post with no recorded identifier, or a cost no one could attribute.

Sources: docs/architecture/skills-and-flows.md (load-once rule, flow authoring standard, Skill Attribution), docs/architecture/media.md (one door, receipt at submit, asset model, publish gate), docs/architecture/connections.md; docs/architecture/agents-runtime.md §Gateways, docs/architecture/data-governance.md (new data sources), docs/DECISIONS.md (ADR-028), Don's product direction, 2026-09-16 (task 410 review) and 2026-10-06 (registry; three ways to run; adding and improving), skills/ and flows/ (the names in the table) · Last verified 2026-10-06