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

Goals, tasks & artifacts

Pillar 02 · Goals, tasks & artifacts

A goal is the why, a task is the work, and every output lands as a version you can see, judge and ship.

Everything your agents make lands in one place, as versions you can approve.

Goal
the why
a number you are moving, a practice you keep, a state you are becoming
Task
the unit of work
a few hours of delivery, with its brand, its skill, its reviews
Deliverable
what it made
an output someone should review, use or publish
Version
one exact state
what you comment on, rate, approve and publish
A labelled diagram, not a screenshot. The chain is loose on purpose — a task need not serve a goal — but the further work sits from one, the harder it is to justify.

A goal is the why: a number you are moving, a practice you are keeping, or a state you are becoming. A task is a few hours of work that serves one. It carries its brand, its status, the skill chosen for it and why, its versions and its reviews. Everything an agent makes lands on the task it came from, so chat messages point to tasks and never become the place a task lives.

What you do
  • Set the goal, or approve one the agent proposes.
  • Open any output in the Workbench and comment, rate, approve, redirect or reject.
  • Share a version with a person, or publish it through a connection.
What your agent does
  • Breaks the work into tasks with clear outputs.
  • Lands every output as a version with its checks already run.
  • Marks which outputs are results, so you review what matters.
  • Picks up your comment on the version and addresses it in the next pass.

One surface opens any kind of output — a document, an image, a video, a page, audio, a data file — each in the viewer that suits it, so you never leave to see what an agent made.

The Workbench with a Code Pineapple task open: version 3 of a pin image in review, format tabs across the top, the details, deliverables, comments and versions rail on the right
Screenshot of the Workbench on a Code Pineapple task: version 3 in review. The rail holds details, deliverables, comments and versions; the Pin action publishes an approved version through the connection.
Mode What you do
Read See the output and its comments. The default when you arrive from a chat card.
Edit Change it. Saving creates a new version; the old one stays.
Review Read, plus a rating (1–5), a decision — approve, redirect, reject — and a note, saved as a review on the task.

A lineage panel shows what produced each output: the task, the run, the skill and its version, and for media the generation receipt. When something is wrong, you can see whether to fix the input, the skill or the brand rule.

A deliverable is an output marked as a result, as opposed to the drafts and working files made on the way. Marking is explicit, so review shows what matters rather than everything the agent touched. The calendar shows deadlines, appointments and publishing plans together; an entry refers to the task or post it schedules and never copies it.

A version is one exact state of an output. Editing makes a new one; the old one stays with its comments and its rating. Comments anchor to a passage, a region, a timecode or a line on a specific version, so “warmer palette on v2” stays on v2 when v3 arrives. Approval is on a version too, which is what makes “approve the thing I actually looked at” unambiguous.

Ratings ride the output and roll up to the skill that produced it, never to the task as a whole: a task that ran nine skills and scored “3” teaches nothing. The trail of versions and notes is what lets the system see which change moved the rating, and why. See Getting sharper.

Every output has a stable identity in a registry. Its bytes sit in durable storage; its name or folder is only a label that can change. So you can rename a deliverable, retitle a task or reorganise folders and every link, chat card and calendar entry still works. The rule exists because the opposite kept happening: four different ways of spelling a file path each broke the display, silently.

Structure is written by the tool that made the output, at the moment it made it — which task, which tags, which scene. Nobody files things afterwards, and nothing is guessed later from a path. That is the only way the picture stays complete when agents make hundreds of outputs a week. The current version of a brand asset is promoted into the brand’s library from its task rather than copied.

Two different things share the word publish, and mixing them up is expensive.

Kept for good Shared or published
What it means The finished file is stored and registered, so “approved” never refers to a file that exists only on someone’s disk A version is put in front of someone else: a person, a page, a channel
Who does it The system, as part of finishing the work. The publish gate will not mark a task done until it has happened You, or an agent on your explicit instruction
Can it be undone? Nothing is deleted by marking a task done A post or page can be taken down, but what someone already saw or downloaded cannot be recalled
What is recorded The registry entry, with the version and the run that made it The version, with the identifier that came back: a URL, a post id, a listing

Publishing to the world is an action on an approved version. It goes out through a named connection under that connection’s scope; the connection records success or failure per item and the identifier that came back, which is what later lets a click, a sale or a comment be matched to exactly the version that shipped. Approval is a decision; publishing is an action.

Sharing is a permission on a specific version, for a specific person, for a specific purpose:

Permission The recipient can The recipient cannot
View Open the version Change it, download it, or see other versions
Comment Leave feedback attached to that version Approve it or edit it
Approve Approve that version or request changes Publish it anywhere
Download Export the file, where you allowed it Redistribute it under your name — that is a contract, not a control

Two rules hold across all of them. A new version never inherits the previous version’s approval: if v3 replaces an approved v2, v3 waits for its own approval. And a client’s approval never authorises public publication: approval says the work is accepted; publishing stays your decision.

Holiday activity book — cover, version 3shared by Sam · for Riverside Books · fixed version

Approved for print on 12 September. Please review the cover and confirm by Friday.

  • Riverside Books (client)view comment approve download
  • Comment on v3 — “Can the ISBN sit lower?”returned to task
  • Approval on v2given 9 Sep does not carry to v3
Approve v3Request changesAccess: revoke
A client review page as intended — a labelled mockup, not a screenshot. Today a page can be hosted; the recipient identity, per-version permissions and revocation shown here are designed, not built.

Pages and collections. A collection is a chosen, ordered set of deliverables — the unit you share when one output is not the story. A client delivery page is a collection fixed to the delivered versions, so what they approved is what they see; a portfolio follows the current approved version so it never goes stale. Collections point at versions and never copy them. Today a page is composed and deployed by an agent from the outputs you name, you review it as a deliverable, and its address is recorded on the task; a page that follows updates, and a self-service composer, are intended.

Feedback from outside only helps if it lands where the work is. Today a client’s comment reaches you by chat or email and you record it on the version, where the agent picks it up like any other review. The direct path, from the recipient to the version to the agent’s plate, is intended.

For builders — what is and is not an artifact
  • One writer for tasks and versions. Tasks and their versions are created and appended through one sanctioned path each, never written directly; that is what keeps status, versions and reviews consistent across chat, the Workbench and scheduled runs.
  • The registry owns identity; storage holds bytes. Prose that people edit is versioned as text; media lives in the registry with durable object storage behind it. Either way, what a card, task or calendar entry points at is the identity, never the location.
  • The publish gate. A task cannot be marked review or done while a media file in it has no completed publish into durable storage. An explicit, logged opt-out exists for exceptional cases.
  • Not artifacts: a chat message (it references artifacts), a run (it produced the artifact and has its own receipt), and an unmarked working file (kept for lineage, not shown for review).
  • Attribution needs a tracked link. Matching a visit or a lead to the page it came from needs a tracked destination link per brand; that registry is the missing piece for landing-page attribution and lead capture.

Sources: docs/architecture/work.md (spine, Workbench modes, calendar), docs/architecture/artifacts.md (registry, versions, structure as a by-product), docs/architecture/media.md §Publish gate, docs/architecture/measure.md (tracked destination links), docs/DECISIONS.md (ADR-028), Don's product direction, 2026-09-16 (task 410 review — sharing and publication) · Last verified 2026-10-06