A crystal on your desktop that runs AI agents for you

1. 1Meet Verse0:00
2. 2What an agent is0:26
3. 3The model plans, the code decides1:11
4. 4One gate for every action1:43
5. 5You stay in charge2:26
6. 6Outside text can't give orders3:14
7. 7Memory3:54
8. 8Skills and teams4:21
9. 9Your other computers5:08
10. 10Who does the thinking5:35
11. 11When something goes wrong6:07
12. 12Where it stands6:41
13. In short7:12

The model plans. Plain, checkable code decides whether that's allowed, does it, checks it worked, undoes it if it didn't, and writes everything down.

At a glance

Verse speaks

Kitten TTS v0.8 mini, on your device

Verse listens

Moonshine v2 streaming, on your device

Verse remembers

A small vector memory, on your device

Agents in the app

The scribe, for notes, reminders and summaries, and the built-in demo agent. You make more with New agent on a collective's board, or in platform/agents.json.

Skills and teams

Your own skills, instructions you write once and use with /name, and collectives, teams you draw on a board and ask with @name

Other computers

Verse Node runs agents on your other computers, paired once with a 12-character code. Your keys stay on the main one.

Models

On your computer by default (gemma3:1b on Ollama). Online: Verse AI, Claude, OpenAI or Kimi. A small backup model runs inside the app when nothing else answers.

Safety

Nothing is allowed by default. Bigger changes wait for you, every change is checked, and a change that fails is undone.

Connections

23 outside services through MCP servers, all off until you switch them on

Runs on

Windows, macOS and Linux

Versions

Platform 1.1.1 in all three languages. Verse Agent app 0.1.0.

Tests

C# 791, Python 533, Node 532, Verse Agent 191, with 46 fault-injection checks shared by all three languages

Where it stands. Working end to end. Verse Agent and Verse Node have installers for Windows and Linux, not macOS; they aren't code-signed yet, and nothing updates by itself. Some screens show real data but can't change it yet: the Charter window's form (make agents on a collective's board instead), editing rules, switching one tool off, and trusting or retiring learned skills. They say so on screen.

Talk to it

Space hold

Hold it and speak, then let go. The microphone is open only while you hold the key. The Talk button does the same with the mouse.

H

Hands-free listening. Start with “Hey Verse” and say what you want. For 25 seconds after an exchange you can keep talking without the wake word. Verse mutes its hearing while it speaks, so it never answers itself.

Enter

Type in the box at the bottom, “Ask Verse, or tell an agent what to do”, and send it.

Space again

Pressed while Verse is talking, it stops Verse at once. You always have the floor.

Verse answers in one to three short sentences, or up to six when you ask it to explain something. The line it's saying, or the one you just said, is typed out under the crystal. Verse listens and speaks in English.

Things Verse does without asking a model

These work even when the model is slow or offline. Verse listens in English, so say them in English.

Anything else is a conversation. When what you ask is real work, Verse hands it to the agent that fits and says who's on it.

Give an agent work

1. Ask Verse in plain words: “Can you get the scribe to write down the plan for Friday?”
2. Start the request with the agent's name after an at sign: @scribe write down the plan for Friday. As you type @ or / at the start of the box, Verse suggests the names it knows.
3. Or type the task, click +, choose Agent, pick the agent and press Enter. The message goes straight to that agent as a task instead of to Verse.

Good tasks say what done looks like. “Write a three-line summary of today's notes into summary.md” finishes faster and better than “sort out my notes”.

Write skills and build teams

A skill is a set of instructions you write once and use whenever you like. Open Skills (key 8), stay on Yours, choose New skill, and give it a name, what it's for and the instructions, such as “Check every name and number against the source before you use it.” Then start a request with its name after a slash: /careful check the guest list for the party. Verse follows it for that request, and if it hands the work to an agent or a team, the skill goes along.

A collective is a team of agents, and even of smaller teams, that takes on a request together. Open Agents (key A), choose Collectives and New collective, give it a name and say what it's for, then press Open the board:

1. Drag your agents onto the board from the left.
2. Drag a wire from Verse at the top to the agent that takes your requests.
3. Drag wires from that agent to the agents it's in charge of. An arrow shows who answers to whom.
4. Press Save collective. The strip along the bottom says what's still missing, if anything.

Then ask it: @research-team compare three laptops under a thousand dollars. The agent in charge plans the work in up to six steps among its team, each step waits for the ones it needs, and when everything's done Verse tells you what the team achieved. Skills and teams combine: /careful @research-team compare three laptops. The run shows in Tasks like any other work, and cancelling it there stops everything it handed out.

Need a new kind of agent? New agent on the board makes one on the spot: a role, what it's for, the tools it may use, and Quick or Thorough limits. It's ready at once and lands on the board.

Put agents on your other computers

A node is another computer in your home or office running Verse Node. Agents you put on it work there, with that computer's files and tools.

1. On the board, choose Add node. Under Get Verse Node onto that computer, press Save beside the Windows or Linux installer, carry it to the other computer and install it there. Verse Node opens and shows a pairing code, such as 7KQ4-M2XD-9PRW.
2. Back in Add node, pick that computer from the ones Verse finds on your network, or type its address, type the code, choose what to Call it, and press Pair.
3. The node lands on the board as a circle. Wire it under Verse or an agent, then wire below it the agents that should run on that computer. Click the circle to write What this node does and to choose whether it Opens as a window or a terminal there.
4. Save the board. Verse sets the node up by itself, and any request to that collective can now give the node its part.

On the other computer, a window or a terminal shows every step its agents take. Ask Verse “What's on my office computer?”. Your keys never leave your main computer: the node's agents think with Verse's models, through Verse. Nodes work while the Verse Agent window is open on the main computer.

Follow the work

Each agent appears as a small crystal orbiting Verse, up to twelve of them. It glows while it works, flares when it acts, breathes gold while it waits for you, and rings when it finishes or fails. A bolt of light runs between two crystals when one hands work to another.

Verse tells you about the work as it happens: when a task starts, needs you, finishes or gets stuck. Urgent news, like an approval, a stuck agent or your task failing, may cut into what it's saying (“Oh, hang on, an agent's calling me.”), and then it picks up where it left off. The Tasks window shows each task's progress, plan, helpers and what counts as done. History replays any task step by step with every safety check, without running anything again.

Say yes or no

When a step would change something that matters, the agent stops and asks. Verse says so out loud, the state under the wordmark turns to Needs you, and the Agents button turns amber with a count. The Needs your go-ahead window (key 3) shows what it'll do, how big a change it is, and whether it can be undone.

Try it. Say you've given the scribe your Slack connection:

• Hold to approve: press and hold until the bar fills, which takes 1.2 seconds. A stray click never approves anything.
• Deny: one click, because saying no is always safe. The agent finds another way or stops.
• Or answer Verse: “Yes, go ahead” or “Deny it”. You approve the exact action you were shown. If anything about it changes before it runs, it has to ask again.

Look after memory

What Verse knows about you

Settings › Memory lists every fact, with Forget that and Forget everything. Verse only stores what you said yourself, never guesses, and refuses anything that looks like a password, key or card number.

What agents know

The Memory window (key 9). Notes an agent saved wait On hold until you approve them with a hold, or reject them. An agent can never approve its own note.

Connect outside services

Tools and connections (key 7) lists 23 services. Each is off until you switch it on. If one needs a key, Verse says which and keeps it off until the key is saved, encrypted. Then you choose which agents may use it. Reading is allowed straight away; anything that changes something for you, like sending a message or updating a ticket, is prepared first and waits for your go-ahead.

Work, acting for you

Microsoft 365, Google Workspace, Slack, Jira, Confluence, Notion, Airtable, Todoist, Linear, HubSpot, Sentry, Zapier

Knowledge

Microsoft Learn, library docs (Context7), arXiv

This computer and its devices

A web browser (Playwright), a document reader (MarkItDown), code search (Serena), GitHub, databases (DBHub), the Windows desktop, phones and tablets (mobile-mcp), Home Assistant

Choose who does the thinking

The Models window (key 0) shows the model on this computer, an optional online model, and how the work is split. To add an online model, pick Verse AI, Claude, OpenAI or Kimi and enter the key. For Verse AI you also enter the secret and the server address. Check and save refuses a key the provider turns down. Then pick a model, choose how much goes online, and press Use this model.

When needed

Each call goes where it fits

Half

About half the calls go online

Everything

Every call goes online

Private things always stay on this device, whatever you choose. If no model answers at all, Verse switches to a small backup model that runs inside the app on your graphics card, tells you so, and answers “What's wrong?” with the cause and the fix.

A Verse AI key and secret come from Settings › API Credentials on this site. The Developer Portal explains them, and the hosted service bills in VXT.

Use it from a terminal

The verse-agent command does what the window does, in any terminal on Windows, macOS or Linux, over SSH too: quick commands, a full-screen view with panes you split like tmux, and a line-by-line chat.

# what's running, then a task for the scribe
verse-agent status
verse-agent task scribe "Write a three-line summary of today's notes into summary.md"
verse-agent approvals
verse-agent approve 1

When something's wrong

System health, in the launcher, checks every part of Verse every 5 seconds. The handbook's Problems chapter explains each symptom and its fix:

• The agents aren't running: build the platform with npm run platform:build, which needs the .NET 10 SDK.
• Verse is on its backup model, or the first answer is slow while the local model loads.
• No voice or no hearing: fetch the models.
• A key was refused.
• The crystal stutters: lower the quality, or switch to the oscilloscope.
• An agent keeps getting stuck: look at Second opinions and History.

The crystal is Verse. The text, buttons and windows glow like the phosphor of a CRT tube, with faint scanlines. Everything on screen uses everyday words, like “Changes it can undo” and “Needs your go-ahead”, rather than engineering terms. Nothing is made up: where the platform has no data, or a control isn't connected yet, the screen says so.

Rules the app follows

Plain names first

Tools, sizes of change and events are shown in plain words: write-file is “Write files”, significantSharedWrite is “Changes others see”. Settings › Display › Technical names adds the platform's own names beside them.

Real data only

Every window reads live data. Empty states explain themselves: “Nothing's running. Ask Verse for something and it shows up here.”

Honest about gaps

Controls the platform can't act on yet are shown disabled, with a note that says so.

Business first

Anything that needs you, an approval or a stuck agent, shows in amber: in the top bar, in speech, and in the side rail when side panels are on.

Copy for the ear and the eye

Short, active sentences with contractions.

The phosphor tube

Every colour in the interface is mixed from two values: lit phosphor and unlit glass. Change the tube in Settings › Display and everything recolours at once. This page works the same way:

Two signal colours sit outside the tube and never change: amber for anything waiting on you, and red for failures, Deny and Never. The 3D scene keeps its own palette: cyan, violet and champagne on a deep void.

The crystal

Verse is a single mesh of 870,000 triangles with baked colour, roughness and normal maps. Its shader sorts every texel by hue into three materials:

Smoky champagne quartz

See-through glass: physical transmission, quartz's index of refraction (1.544), champagne absorption, dispersion, clearcoat and thin-film iridescence. It's double-sided, so the back facets show through.

Amethyst cores

Opaque, with a breathing violet glow, lit from inside by a pulsing light.

Cyan veins

Flowing energy, plus a 3D web grown from the painted veins, with pulses travelling along it and star flares where it joins.

Its mood follows what Verse is doing, blended smoothly:

Quality Low draws at device pixel ratio 1, without multisampling, with half-resolution transmission and 1024-pixel shadows. High goes up to 1.75, with 4× multisampling and 2048-pixel shadows.

The agent constellation

Each agent gets a small crystal on an orbit around Verse, tethered to its heart, up to twelve. More agents glow inside the main crystal and take over a crystal when one retires.

Spawn

Born at the heart, it arcs out to its orbit with a bolt along the tether.

Activity

Its core brightens, its spin quickens, and pulses flow inward along the tether.

Thought

A soft violet shimmer, also used when a step is sent back.

Flare

A cyan flash and a small kick.

Transfer

A bolt of light between two crystals, when one hands work to another.

Attention

A slow gold breath while the agent waits on you.

Complete

A bright bloom and an expanding ring.

Fail

An ember flicker, a shiver and a ring, also used when a run crashes and will retry.

Retire

It spirals back into the heart.

A flood of events stays readable. Continuous work is a level that eases up and decays, so a thousand events a second keep a crystal lit instead of replaying a thousand animations. Flourishes are throttled per agent and capped across all of them, lifecycle cues are never dropped but spaced 180 ms apart, and with the operating system's reduce-motion setting only lifecycle cues play.

The oscilloscope

Settings › Display › Show Verse as › Oscilloscope replaces the crystal with a two-trace analog oscilloscope. Channel 1 is Verse's voice; channel 2 is your microphone while it's open. Each frame fades the last like phosphor afterglow, and a slow, low wave on channel 1 means Verse is thinking. With the oscilloscope, the 3D scene and its 36 MB model are never loaded, and at rest it redraws about ten times a second.

The patch bay

A collective's board is drawn as a patch bay on the tube: a dot grid that pans and zooms with the view, flat square phosphor modules, and glowing patch cables, the only curved lines on the board. Every colour comes from the tube, so the Tube setting recolours the board too.

Verse

A filled panel fixed at the top, with the VERSE wordmark and one output jack below it

Agent

A square panel with its name, its job and its skills as /name, an input jack on top and an output jack below

Collective

The same panel with a double border and a “team” badge, and no output jack, because it runs its own team

Node

A dashed circle with a lamp: lit when Verse is connected to it, amber while it connects, dim when it's offline

Cable

A curve from a manager's bottom jack to a report's top jack, ending in an arrowhead. It turns amber when it leads to a module with a problem.

Saving sends a short signal pulse down every cable. With reduced motion there's no pulse, and the board opens without its animation.

Type, shape, motion and sound

Type

Roboto Condensed for labels and buttons, VT323, a pixel terminal face, for readouts, the caption and the composer, and Roboto Serif for reading in the handbook. All bundled, nothing fetched while it runs.

Shape

Every corner is square. The only rounded corner is the CRT glass. Frames and rules are 2 px lines, and filled readout cells are separated by 3 px seams, as on this page.

Texture

Scanlines over everything, a soft phosphor glow on text, and see-through windows. Scanlines and glow can each be switched off.

Motion

Stepped and quick, like old hardware. Status dots blink in steps, windows open in 260 ms, and the spoken caption types out at 45 characters a second behind a block cursor.

Sound

The only sound is Verse's voice. There are no clicks or chimes.

Layout

By default the screen is bare, so the crystal has room, and news arrives as toasts in the corner. With side panels on, a left rail lists the agents and a right rail shows what needs you and the latest activity.

The launcher (W) groups every window: Work (Agents, Tasks, Needs your go-ahead, Second opinions, History), What agents can do (Rules, Tools and connections, Skills, Memory), System (Models, System health, Settings) and Help (the handbook). Every window is a floating panel you can drag; the focused one has a bright border.

Every window

Keys and gestures

None of these keys act while you're typing in a field. Approving an action, approving a memory note and removing a saved key all use a hold: the button fills over 1.2 seconds, and letting go early or sliding off cancels. When Verse asks “Should I approve it?”, a bare “yes” or “no” answers it for 2 minutes.

Voice and hearing

Voice

Kitten TTS v0.8 mini (80 million parameters) in a background worker. The model is ready in 1.5 to 3 seconds, the first audio arrives about 1.1 seconds after Verse starts a line, and there's no silence between chunks. Eight voices: Rosie (the default), Bella, Jasper, Luna, Bruno, Hugo, Kiki and Leo, at 0.5× to 2× speed.

Crystal FX

A light lift in presence and air, a slow stereo shimmer and a short glass-bowl tail, mixed low so the words stay clear.

Hearing

Moonshine v2 medium, streaming English recognition (305 MB), in its own worker, with echo cancellation, noise suppression and automatic gain. What you say while it's still loading is kept, up to about 30 seconds, and recognised once it's ready.

Memory model

bge-small-en-v1.5 embeddings (34 MB), for Verse's memory of you.

Downloads

All three models are fetched at pinned versions and checked by SHA-256 before use.

How Verse talks

Verse is curious, warm and a bit dry. It says plainly that it's an AI if you sincerely ask, follows up on what it remembers, keeps humour light, and is brief when you're busy or frustrated.

• It's written for the ear: sentences of about 8 to 12 words, one idea each, active voice, contractions always.
• A turn is one to three sentences, with at most one question, at the end.
• No stock phrases (“Certainly!”, “Great question”), no inflated words, no em dashes, no markdown or emoji, no flattery.
• It apologises once, briefly; says “I don't know” plainly and offers a next step; and never reads raw error codes aloud.
• News about the agents comes from a phrasebook, not a model, so it's instant and never wrong about what happened.

Similar news within 1.5 seconds is batched (“Three tasks just wrapped up.”), a tool error fixed within 5 seconds is never mentioned, and stale news is dropped.

The handbook

Press F1 for the Verse Handbook, laid out like a printed manual: two-page spreads, chapter openers with big pixel numerals, thumb tabs down the edge, and a search across the whole book with Ctrl F. Its spot colour follows your tube. The same text is in a terminal with verse-agent handbook.

1. Meet Verse
2. Talking
3. Getting around
4. Agents
5. Your go-ahead
6. Tools, memory
7. Models
8. Settings
9. Good habits
10. Problems
11. Terminal

Accessibility

• The oscilloscope needs almost no graphics power. With reduce motion set, the caption appears at once, traces hold still, window animations are off, and the constellation plays only lifecycle cues.
• Windows are dialogs named by their titles, the caption is a polite live region, and switches, menus and segmented controls carry their roles.
• Everything important works by voice, by keyboard or by mouse. Approving is a deliberate hold, never a stray click.
• Statuses differ by shape as well as colour: a diamond for waiting, a tick for done, a cross for failed.

Agents and their charters

An agent is a worker with one job. Its charter is its job description: what it's for, which tools it may use, how far it may go on its own, its budget, when it must ask, what it may remember, and where its thinking may happen.

The scribe's file tools reach one folder only: Documents/Verse Notes. Writing a file is reversible: the change is staged, read back, and only then kept.

A charter also sets escalation triggers, a risk policy, a memory scope and where its data may go. Blocks you leave out get safe defaults: 20 steps, 15 tool calls, 200,000 tokens and 600 seconds.

To make an agent, use New agent on a collective's board: a role, what it's for, up to 12 tools, and Quick (8 steps, 6 tool uses, 5 minutes) or Thorough (20 steps, 15 tool uses, 15 minutes) limits, with 80,000 tokens of thinking. The platform registers it at once, with no restart, and adds one allow rule per tool up to that tool's own size of change, so anything at “changes others see” or bigger still asks you first. Tools that belong to a connection aren't offered there: they're given in Connections, which knows their keys. The Charter window's five-step form shows any agent's real charter, but can't save one yet.

Each agent works through a bounded loop: look, update what it believes, plan, propose one action, and then the platform validates, authorises, runs and checks it. Budgets are hard limits. When an agent is stuck or unsure, it sends a short summary, never its whole conversation, to the central model for a second opinion.

Skills and collectives

Your skills

A /name skill reaches the model as your own instruction, headed skill: careful, and goes with any task it's handed to as a constraint. On a board each module can carry up to five skills of its own, which shape that agent's work in that collective. Names use lowercase letters, digits and dashes, up to 40 characters. You can keep up to 100 skills, each with instructions up to 4,000 characters, and use up to five on one request.

The board's rules

Checked as you edit and again when you save: a tree under Verse, with every module wired to exactly one manager; at most 16 modules and five levels; a collective module is a leaf; only agents below a node, at least one, and no node inside another; collectives nest at most three deep, and none can end up inside itself.

A run

A module with no team gets the whole request. An agent with a team takes charge and plans among its team and itself. Several modules wired to Verse are led by the collective, speaking as Verse. A plan has one to six steps, each a task of its own; steps with nothing to wait for run at the same time, and a waiting step gets what the earlier ones did. Whoever planned sums up in two to four sentences. The run counts as done when at least one step worked, and the summary names any step that failed or was skipped, and why.

Approvals

You asked for the run, so the hand-offs need no approval. Anything a member then does still goes through its charter, the rules and approvals. A run still going after 30 minutes stops and fails.

Nodes

Verse Node is a small program that holds a whole agent platform of its own. Verse works out each node's setup from the boards: its teams, their agents and rules, the skills they carry, the connections they use that need no key, and the model choice, never a key. It sends a setup only when it changed, and one that arrives during a run waits for the run to finish.

• Model calls go through Verse. A node points its models at a relay that hands each call to Verse, which sends it only to that model's configured address and adds the real key there. So a node's agents use Verse's own models, and while Verse is away they can't reach a model at all.
• Runs. A local-only request never goes to another computer. A node that's offline fails its step at once with the reason, and one that goes away for five minutes during a run fails it. If Verse is away when a run ends, the node keeps the result for an hour.
• Approvals. A node's agents still ask before anything at or above “changes others see”. Verse lists them in Needs your go-ahead as “On office: …”, and your decision goes back to the node.
• Only with the window. The node hub runs in the desktop app, so a board with a node can't be saved from the terminal command.

Tools

Tools are narrow by design: separate read and write tools, and no general shell, SQL, HTTP or file tool. Registering a tool grants it to no one.

A step's prompt lists at most 16 tools, ranked by how well they match the goal and the step, and the step's own tool is always kept. Tools can be switched off for everyone or for one role, and the gateway refuses a switched-off tool too. Web searches go to Brave, Tavily or Exa, with at most 20 results.

In the Verse Agent app only the scribe's four tools are granted. The build, test, lint and git tools stay off there, because they run a project's own commands.

Connections

Connections bring in tools from outside services through MCP servers. Nothing a connection sends back is trusted on its own; it goes through the same checks as everything else. A connection that switches things in the real world, like Home Assistant, asks for your go-ahead for every action except reading.

• Keys are sealed by the operating system and bound to their server, the variable's name, and a fingerprint of the server's setup. If the setup changes, the key is withheld.
• Each server starts with a minimal environment, so no server sees another server's keys or the model keys.
• A server that can't run, because a key is missing or its setup changed, stays off with the reason shown instead of stopping the platform.
• Giving an agent a connection adds the service's tools and a rule that allows them up to changes others see, so anything at that size or bigger still waits for you. A service's change actions go preview, approve, apply, and applying always needs a person. Taking access back removes exactly the rules that were added.
• Every imported tool re-lists its definition after a restart or every 5 minutes, and a call is refused if the server swapped it.

Models

A model does the thinking. By default it's a small model on your computer. You can add an online model for harder work and choose how much goes to it. Anything private stays on your computer no matter what.

Sizes that run on your computer

Routing. A bias from 0 to 100 sets how much goes online: 0 is local only, a hard ban; 100 is online only; anything between is the chance a call goes online. Each role can have its own bias. A call falls back to the other tier only for passing failures, like a timeout, a rate limit or a server error, or when the prompt is too long. A refused key or a bad request is reported, never “fixed” by sending your prompt somewhere else.

Castes. Roles can also be given a caste: lower is local only, middle is half and half, elite is online only. A caste wins over a role's bias, which wins over the overall bias.

What Verse AI adds

Verse AI is the platform's own model API, from this site: OpenAI Chat Completions plus what the agents know about each call.

Only tools it may use

The reply's shape allows only the tools this agent is allowed, with each tool's exact inputs

Thinks as hard as the step needs

Reasoning effort follows the step's depth

Reuses what it already read

A cache key for the instructions every step repeats

Knows who is asking

Each call says its purpose, the agent's role, the task, and whether it must stay local

Too long goes elsewhere

A prompt too long for the model is sent to the other tier instead of failing

The backup model

When neither the local nor an online model answers, Verse talks through a small model that runs inside the app on your graphics card. It can't give agents work, and it's unloaded once the usual model is back.

At launch the app warms the local model before your first question; until it's ready, Verse handles commands and small talk itself and says it's still waking up.

Memory

There are three separate memories, plus skills.

What Verse knows about you

A small vector store on this machine only. A fact is kept only if most of its words are things you said this turn or the one before, never if it looks like a secret, and a near-duplicate refreshes the old fact instead of adding one. Up to six relevant facts reach the model as evidence, and Verse never recites them unless you ask.

What agents know

Long-term memory in six namespaces, with a single way in: checked for where it came from, de-duplicated, checked for contradictions, then held or promoted. An agent can never promote its own memory, and only verified memory reaches a model.

The shared board

What agents tell each other during a task, each item scored so that old or uncertain items sink.

Skills

Reusable programs with tests and a permission list. Only validated or trusted skills can be used, and they run in the sandbox.

Approvals and safety

Agents work on their own until a step would change something that matters. Every action has a size, and big enough ones wait for you. Every change is checked; a change that doesn't check out is undone. Everything is written down.

• When an agent must ask: the last two sizes always wait for a person, and so does anything above the agent's own limit. A model that sounds sure can never lower a size or skip an approval.
• Copied from somewhere else: if an action uses something that came from untrusted content, such as an email address copied from a web page, and not from your request, “allowed” becomes “ask you”.
• What an approval binds: a fingerprint of the exact action, its arguments, its target, the tool and the agent's authority. If any of it changes before it runs, it's refused and the agent must ask again. Requests expire after 24 hours.

What every action goes through

1. Check its shape
2. Size the risk
3. Rules, deny by default
4. Your go-ahead, if needed
5. A one-time permit
6. Input screen
7. Prepare
8. Run, sandboxed or as a transaction
9. Output screen
10. Check the result independently
11. Keep it, or undo it
12. Write it down

Screens

On the way in: task alignment, argument size, paths that try to escape, web addresses (private and cloud-metadata addresses are refused at connect time), secrets, SQL scope and rate limits. On the way out: leaked secrets and oversized output are blocked, and text that looks like injected instructions is marked untrusted.

Trust levels

Every piece of context carries a level: 0 untrusted outside data, 1 retrieved internal data, 2 an agent's observation, 3 your instruction, 4 system policy. Only levels 3 and 4 can be instructions, and that's enforced by the code's types, not by asking the model nicely.

Sandbox

Code runs with an isolated working folder, a cleared environment, no network by default and resource limits. The container sandbox (no network, read-only root, every capability dropped) is a real boundary on all three operating systems.

Always on

Nothing is allowed unless a rule says so. Anything that can't be undone asks you first. An agent that sounds sure still has to ask.

The terminal command

verse-agent is Verse without the window, in any terminal. It needs Node 22.18 or newer and the built platform. It's named verse-agent, not verse, so it never shadows another tool.

In chat, start a line with @scribe to give the scribe work. Panes split like tmux: press Ctrl+B, let go, then % splits side by side and " top and bottom. When an agent needs your go-ahead, a Needs you pane opens by itself without taking your typing away.

Updates and distribution

• The platform ships as versioned packages with checksums: ten NuGet packages, runnable API and worker zips (they need the .NET 10 runtime), a Python wheel and sdist, and an npm package. Each is smoke-tested the way a consumer would install it.
• Containers: separate non-root API and worker images, and a compose file with PostgreSQL, OPA, an OpenTelemetry collector and a stand-in model.
• Verse Agent has installers for Windows (one account, with verse-agent on its PATH) and Linux (a .deb and an AppImage). They carry the app, the terminal command, the platform built with the .NET runtime inside, and the Verse Node installers, about 1 GB in all.
• Verse Node has installers of its own for Windows (for every account, with a Windows Firewall rule for private networks only) and Linux (a .deb and an AppImage), roughly 140 to 180 MB each.
• There's no macOS installer, the installers aren't code-signed yet, and nothing updates by itself: you install the newer installer, or pull the source and rebuild. From source it runs as before: npm install (which also fetches the voice, hearing and memory models), npm run platform:build, then npm start. Download them under Downloads below.

The pieces and how they talk

• The app starts the platform on a local port with a fresh 48-character key that it never shows the window, turns off the shipped developer key, and restarts a crashed platform up to three times.
• The window never sees the key or the port. Every call is a message that's honoured only from the app's own page, with ids checked and text capped at 2,000 characters.
• The verse-agent command runs the same supervisor and companion code in plain Node, or attaches to a running verse-agent serve.
• Verse Node on another computer connects to a hub in the app's main process over an encrypted WebSocket. The platform hands a node its step through a gateway on 127.0.0.1, with a fresh token each launch.

One central model, many bounded agents

A large central model coordinates many smaller agents. Each has bounded autonomy, a typed state, a short-range planner, local memory, its own tools, an estimate of its own uncertainty, checks on its work, and a way to ask for help. What a model sends back is only ever a strictly parsed decision: act, revise the plan, finish, or escalate. The model never calls a tool.

The C# solution has thirteen source projects, including the harness command, plus four test projects and three examples, with strict boundaries: the core logic never references a model SDK, a database library, a web framework or a workflow engine.

The loop

1. Look
2. Update beliefs
3. Plan
4. Propose one action
5. Validate
6. Authorise
7. Run
8. Check
9. Update state
10. Save a checkpoint
11. Continue, finish or escalate

• Budgets for steps, tool calls, tokens and time are hard. A model call is let through only if its answer still fits, and a helper gets at most what its parent has left.
• Repeating the same proposal, or making no progress, is caught and stops the run.
• A finish counts only when every machine-checkable goal is met. A bad finish or a bad plan is sent back, and the refusal is recorded.
• Before an action is sent, the decision is saved. After a crash it's reconciled: a recorded result is reused, an action that provably never went out is resent, and anything unknown stops for a person. A side effect that may have happened is never retried.

The action gateway

The only path from a decision to a real effect. Every stage can say no, and no is the default.

• Proposal ids are minted by the runtime, never taken from the model, and a proposal runs at most once.
• A tool that can work out its real target from its arguments replaces the model's label for it before any check. A tool that changes something and can't is refused.
• Anything that goes wrong after staging rolls back exactly once, within 30 seconds. A rollback that fails is reported as such.
• Two writes to the same thing at once fail fast. Each agent's real track record feeds back into how risky its actions look.

Durable tasks, transitions and checkpoints

Tasks are accepted once per key, retried with backoff (three attempts by default), set aside after repeated crashes, and parked while they wait for an approval. An approval is decided exactly once, and the task then resumes from its checkpoint. Every transition is stored, in order, and never rewritten.

Checkpoints carry a version that works as a fencing token: of two workers resuming the same task, only the one whose checkpoint lands may act. Verse reads the platform's own records of the last ten tasks you may see, so when you ask “What went wrong?” it answers with the failing step and the exact error, in plain words, and never guesses.

The platform's API

Every route is under /api/v1, needs an operator or approver key, and is rate limited per key (120 requests a minute by default). Another tenant's objects answer “not found”, so ids don't leak.

A conversation turn, end to end

1. You speak or type. Moonshine turns speech into a line, and the app checks it for a command. Commands are handled at once.
2. Otherwise the window sends your message, the last 12 turns and the recent activity. The main process recalls up to six facts about you and asks the platform for a reply.
3. The platform builds the model's context: the persona and speaking rules as system policy, your message as your instruction, the conversation and remembered facts as data, and the agents' work as observations. It goes through the same model runtime as the agents, so the same model choice and privacy rules apply.
4. The reply carries what to say, up to five facts to remember, up to two topics, and optionally a job for an agent, which becomes a real task.
5. Proposed facts are checked against what you said before they're stored.
6. The window shortens the reply for speech and speaks it.

Data placement

A charter, a task or a tool's output can mark data as local only. A run takes the strictest of the three and keeps it: once local-only output is seen, every later call in that run stays local. Local-only work goes only to local models, never online, not as a fallback, not through the bias, not for a second opinion, and it's refused when no local model exists. In the app this is Keep private things here, which is always on.

Security and keys

The app

The window is sandboxed, with no Node access and a minimal bridge that never exposes the platform key. No pop-ups, no navigating away, a strict content security policy, and every permission denied except the microphone.

Model keys

Encrypted by the operating system (DPAPI on Windows, the Keychain on macOS, GNOME Keyring or KWallet on Linux), stored owner-only, and tied to that folder and account, so a copy elsewhere can't be read. The server address is sealed with the key, so editing a file can't redirect it. The window only ever sees the last four characters.

Plainly

A program already running as you can ask the operating system to decrypt. The encryption protects the file at rest: copies, backups, other accounts and other computers.

The platform

Deny-by-default policy that fails closed, structural trust levels, one-time permits, screens on the way in and out, transactional rollback, memory held for review, locks, idempotent runs, an append-only audit, pinned MCP definitions and approvals bound to the exact action. No default credentials in production.

Persistence and observability

• The platform stores its records in PostgreSQL in production, SQLite in tests, or memory during development. Audit, transition and usage rows are append-only.
• In the Verse Agent app the platform keeps its records in memory. Tasks, history, approvals, agents' memories and the shared board last only while the platform runs, and start empty after a restart, including the restarts after a model, key or connection change. Verse's memory of you, saved keys, connection switches and settings are on disk and survive.
• OpenTelemetry spans and metrics carry ids, sizes and hashes only. The app turns telemetry off.
• Evaluation: recorded runs replayed without side effects, injection benchmarks in the style of AgentDojo (measured attack success: 0), tool-use benchmarks, and 46 fault-injection checks compared across all three languages.

Three languages, one behaviour

The C# platform is the reference. The Python port (3.11 or newer, standard library only) and the Node.js port (TypeScript, Node 18 or newer, no runtime dependencies) are faithful, independently tested copies of the whole core: the loop, the gateway, the screens, policy and permits, memory, skills, orchestration, every model provider and MCP. They share one config format, one policy, the same test vectors and the same fault-injection checks. The Verse Agent app runs the C# build.

Stacks and versions

Operating systems

The platform runs on Linux, macOS and Windows, and its CI builds and tests on all three. Verse Agent runs on all three through Electron's Chromium. On Linux the backup model needs VERSE_WEBGPU=1 and saving keys needs GNOME Keyring or KWallet; on macOS the microphone must be allowed; Windows terminals have no tmux, so verse-agent tmux uses its built-in panes. Installers are built for Windows and Linux only. Verse Node has installers for Windows (x64) and Linux (x64 .deb and AppImage); a Mac runs a node from a checkout.

Tests

Build and run

Downloads

Verse Agent 0.1.0, Verse Node 0.1.0 and the platform's release 1.1.1: the versions this page describes. Check any download against SHA256SUMS.txt.

The licence in short: free for personal and commercial use, so build and sell whatever you like with it, but you may not claim the platform as your own or resell or redistribute it as your own product or managed service.

sudo apt install ./verse-agent_0.1.0_amd64.deb
verse-agent-desktop   # the app
verse-agent agents    # the terminal command

# or the AppImage, on any distribution
chmod +x Verse-Agent-0.1.0-x86_64.AppImage
./Verse-Agent-0.1.0-x86_64.AppImage
./Verse-Agent-0.1.0-x86_64.AppImage --cli agents

sudo apt install ./verse-node_0.1.0_amd64.deb
verse-node status     # the terminal command; the AppImage takes --cli status

# if ufw is on
sudo ufw allow 47800/tcp && sudo ufw allow 47801/udp

# point NuGet at the unzipped folder
dotnet nuget add source /path/to/downloads/csharp/nuget --name agentplatform
dotnet add package AgentPlatform.Infrastructure

pip install agent_platform-1.1.1-py3-none-any.whl
python -c "import agent_platform; print(agent_platform.__version__)"

npm install agent-platform-1.1.1.tgz

Every build works offline out of the box, with in-memory stores and a scripted model: no API keys or database needed to try it.