Harnesses#

An agent is two parts and a loop. The computer is what the agent looks at and acts on: a person's own computer, or one machine of an environment. The harness is what decides: it reads what the computer shows and answers the next action. The loop joins them. It looks, asks the harness for a decision, checks the action, shows where it will land, and sends it.

The loop is one piece of code, computatrum/agent. Computatrum runs it on your computer. A hosted agent runs the same code on a machine of an environment. Only the harness and the computer differ, and the harness is a choice you make by its id:

An id is <family>-<version>-<effort>. A version is dotted numbers (1.0) or a date (2026-11-10). It changes when the harness could decide the same task differently. The effort says how much the harness reads or computes before it decides. A scripted harness is scripted-<uuid>: one stored script.

A Mermaid diagram, shown as its source.

flowchart LR
  subgraph loop["the loop (computatrum/agent)"]
    look --> decide --> check --> show --> act --> look
  end
  computer["computer<br/>your desktop, or an environment's machine"] -- "frame, outline, focused window" --> look
  act -- "one action" --> computer
  decide <--> harness["harness<br/>computatrum · scripted · a research model"]

Every harness's actions pass the same checks. An action that sends, deletes, buys or changes an account waits for the person's Allow in Computatrum. A password, a code or a card number is never typed by any harness. An action planned on an old frame is not sent.

Which harnesses you may use#

GET /v1/harnesses lists every harness with available (true or false) and why (one sentence). The console shows the same list on its Harnesses page, and Computatrum shows it in the picker beside the task box. A harness that is not open to you is listed, cannot be chosen, and says who it is for.

The rule has five steps, in this order:

1. The operator has denied the harness to your account or to the organization: not available.
2. The operator has allowed it to your account or to the organization: available.
3. The harness is public: available.
4. Your account has one of the harness's tags, or the organization is in one of its research programs: available.
5. Otherwise: not available.

A deny always wins. An allow or a deny names one harness id, or a family, which covers every version and effort of that family.

Tags belong to an account. An account has zero or more. The operator sets them; you see yours in GET /v1/me (tags) and on the console's Harnesses page. The tags in use today:

Who each harness is open to:

To ask for a tag or a harness, write to [email protected]. Nothing about the research harnesses is sold or metered.

The Computatrum harness#

computatrum-1.0-<effort> is the decider that Computatrum has always had, now one harness among others. Each step:

• read: the vision model describes the frame, only when the screen changed. This is the only place a screenshot leaves the computer.
• decide: the chat model reads the task, the outline of controls, the description and the steps so far, and answers one decision in JSON. It can also ask where something is (locate); the vision model answers, and the chat model decides again in the same step.
• fast picks: between decisions, a typed chooser picks the next routine click off the outline in about a tenth of a second, while the plan is clear and the last action worked.

Its model calls are metered as agent-minutes (the two windows).

Scripted harnesses#

A scripted harness is a program of steps. It asks no model, so a run repeats exactly. Use it for tests, benchmarks, replays, and routine jobs whose steps you know.

{
  "steps": [
    { "step": "Open the editor",
      "action": { "verb": "press", "element": { "role": "button", "name": "Text Editor" }, "intent": "Open the Text Editor" } },
    { "step": "Type",
      "action": { "verb": "type", "text": "Hello", "intent": "Type the greeting" } },
    { "when": { "text": "Hello" },
      "action": { "verb": "done", "summary": "Typed the greeting." } }
  ],
  "patience": 10
}

• action is an action of the loop: click, double_click, right_click, triple_click, press, set_text, type, key, scroll, drag, wait, or the loop's own ask_user, done and fail.
• element is an id of the outline ("e-4") or { "role", "name" }. A control named by role and name is found on the screen when the step runs.
• when is what the screen must show before the step runs: text (a regular expression over the outline), element ({ role, name }), focused (a regular expression over the window title). While it does not hold, the harness waits half a second and looks again, patience times (10 unless you say). Then the task fails and says which step waited.
• then is up to 12 more actions sent after action without another look.
• done is the summary when the script runs to its end.

A step is spent once it is answered, whatever the computer then did. The next step's when is your check. A script holds at most 200 steps and 64 KB.

curl -s $API/harnesses/scripted -H "authorization: Bearer $CW_KEY" \
  -d '{"name": "Greeting", "script": {"steps": [{"action": {"verb": "press", "element": {"role": "button", "name": "Text Editor"}}}]}}'
# → 201 {"harness": {"id": "scripted-3a77f8e1-5d3a-476f-9588-62494cbfd955", "family": "scripted", "title": "Greeting", …, "script": {…}}}
curl -s $API/environments/$E/agents -H "authorization: Bearer $CW_KEY" \
  -d '{"kind": "hosted", "machine": "workstation", "harness": "scripted-3a77f8e1-5d3a-476f-9588-62494cbfd955"}'

A script the API cannot run is refused when you make it, and the error names the step (steps[0].action.verb "explode": one of click, …). Scripts belong to the organization. PUT /v1/harnesses/{id} replaces a script and keeps its id; DELETE removes it. An organization keeps at most 100.

The navigator#

tribe-v2-energy-based-navigator-2026-11-10-<effort> is a research harness. It asks no language model. It asks a model of the brain: Meta AI's TRIBE v2, which predicts the cortical response of an average person to what they hear and see (the brain encoder).

One step:

1. The task is spoken and encoded once. The result is the predicted response, averaged over time, on the cortex's language areas.
2. Each control the agent could press is encoded the same way, from its name.
3. The energy of a control is 1 − cosine(task − m, control − m), where m is the mean of the controls on this screen. What every control shares says nothing about which to press.
4. The navigator presses the control with the lowest energy that it has not pressed in this task.
5. It answers done when no control is left, or after 8 presses.

At xhigh it also encodes the screen itself, as a still held for 20 seconds, and answers done when the screen's energy is lower than every control's.

Measured on the research machine on 2026-11-10: for the task "Open the text editor and write a note" and a dock of five buttons, Text Editor had energy 0.286 and the next control, Settings, 1.120.

What to expect:

• It presses and clicks. It never types, so a task that needs text is beyond it.
• A name it has not read before takes about a minute (the name is spoken, transcribed and encoded); it reads at most 6 new names a step. A name it has read costs nothing, so a screen it knows is decided in milliseconds. At xhigh, a screen it has not seen takes about four more minutes.
• A hosted agent's task ends after 10 minutes, so a hosted navigator gets one or two steps on screens it has not read. Computatrum on your own computer has no such limit.
• It runs on one research machine. GET /v1/harnesses says serving: false while that machine is not answering, and a step asked then gets 503 harness_offline.
• The task's text and the controls' names are sent to the research machine, and their spoken form to a text-to-speech service. At xhigh the screenshot goes to the research machine too. Do not use it on a screen with personal data.

It is an instrument for one question: does a model of the brain's response carry the direction of a task? It is not a competent agent, and it is not sold.

The API#

The routes are under the environments scope. An agent token (what the Computatrum app holds) may read the catalog and ask for a step; it cannot make or change a script.

A hosted agent names its harness when it is made: POST /v1/environments/{id}/agents {kind: "hosted", machine, harness}. Without harness it is computatrum-1.0-normal. The platform checks that you may use the harness then, and again when each task starts: an agent whose harness was taken away stays, and its next task fails and says why.

Errors: 404 harness_not_found; 403 harness_access_required (the message is the why); 503 harness_offline; 429 harness_busy (an organization may have 8 steps waiting on the research machine); 502 harness_failed (the research machine could not decide; the message says why); 504 harness_timeout.

What a harness is given, and what it answers#

input is one step as the loop gives it to any harness:

{ "task": "Open the text editor", "taskId": "…", "step": 0, "maxSteps": 40,
  "frame": { "id": "f-0000002a", "width": 1280, "height": 800 },
  "tree": { "available": true, "text": "…the outline as text…",
            "elements": [{ "id": "e-3", "role": "button", "name": "Text Editor", "actions": ["press"], "rect": { "x": 0, "y": 140, "width": 48, "height": 48 } }] },
  "focused": { "title": "Desktop", "class": "shell" },
  "own": [], "said": [], "history": ["1. press element=\"e-3\" (Press “Text Editor”) → sent, the screen changed"],
  "last": { "worked": true },
  "image": "<base64 JPEG, only for a harness with pixels: true>" }

A decision is one action, and optionally what the harness thinks and plans:

{ "thought": "Lowest energy 0.286: “Text Editor”.", "now": "Pressing Text Editor",
  "step": "Follow the lowest energy", "plan": [],
  "action": { "verb": "press", "element": "e-3", "intent": "Press “Text Editor”", "risk": "none" },
  "then": [] }

Writing a harness of your own#

In JavaScript, a harness is an object with decide(input). The package's own three are built the same way:

import { createAgent, harnessFor, scriptedHarness } from 'computatrum/agent';

const pressFirstButton = {
  id: 'first-button-1.0-normal',
  async decide({ tree, history }) {
    const b = tree.elements.find(e => e.actions?.includes('press') && !history.some(l => l.includes(e.name)));
    return b ? { thought: `The first button: ${b.name}.`, action: { verb: 'press', element: b.id, intent: `Press ${b.name}`, risk: 'none' } }
             : { action: { verb: 'done', summary: 'No button is left.' } };
  }
};
const agent = createAgent({ harness: pressFirstButton, computer });
await agent.run('Press every button once.');

harnessFor(id, { api }) gives the harness an id names. start({ task, taskId, on }), see(view) (the frame, as soon as it is captured) and end({ status }) are optional. The computer is { screenshot, elements, focusedWindow, act, arm, disarm, toFrame, toScreen }; the types are in the package (core.d.mts).

For the operator#

With the operator's token:

Each tag, allow and deny is kept with when it was made and the note. The navigator's worker is scripts/brain/navigator.py serve on the research machine.

What is not built#

• A society's people (societies) are still decided by their own policies, not by harnesses.
• A hosted agent's task is one alarm of 10 minutes, which is short for the navigator.
• There is one research machine, and its worker is started by hand.