What is Veyra Hands
The agent runner behind Veyra: what it does, the harnesses it drives, where it runs and how it works with Veyra Intelligence.
Veyra Hands is the runner that does an agent's work. It starts a coding-agent harness such as Claude or Codex, keeps the session open while the agent works, records checkpoints so a run survives interruptions, and sends every tool call back to the control plane that governs the agent. Veyra Intelligence is that control plane: it decides who works on what, and Hands carries out the run. Hands is built into Intelligence: it is the engine Intelligence uses to run agents, with nothing to download or install separately.
Agents, harnesses and runners
- An agent is a member of your organization in Intelligence, with a role, a manager, a budget and permissions.
- A harness is the program that reads, reasons and edits: Claude, Codex, OpenCode and others. In Intelligence it is the agent's runtime.
- A runner starts the harness, connects it to the control plane and supervises it until the run ends. Veyra Hands is Veyra's runner.
Hands does not replace the harness or change how it reasons. Each harness keeps its own tools and habits; Hands adds the session, the checkpoints and the governed tools around it.
What Hands does
Runs the real harness
Hands starts the harness program itself and speaks its own protocol: Codex through its app server, OpenCode through its server, Claude and Grok through the Agent Client Protocol. The harness signs in with the model account you connected and uses the model you picked. Hands passes that model through unchanged; if the provider rejects it, the run stops with a clear error instead of switching to another model.
Keeps sessions through interruptions
Hands records checkpoints as a run goes. If the connection between Hands and Intelligence drops, the run reconnects and continues where it was. When the harness can resume its own conversation, Hands resumes it; when it cannot, Hands starts a fresh conversation with a short handoff of the task's history, so the agent does not start blind.
Lets you steer a run
A comment you post on the task while the agent is working reaches the running turn, and the agent reads it at its next step. If a run restarts before the model has read a comment, Hands delivers it again. You can stop a run at any time. When the agent asks you a question, it appears in the task and in your Inbox.
Sends tool calls through the control plane
The tools an agent gets from Intelligence (reading and updating tasks, finishing or blocking its work, and the connectors assigned to it) reach the harness through Hands. Each call goes back to Intelligence, which checks it against the agent's permissions before it runs. The credentials behind these tools are scoped to the run.
Verifies what it starts
Harness programs come from pinned builds, checked by hash and packed with each Hands release. Before a harness starts on a machine, Hands checks the installed pack against its release. A missing or mismatched pack fails with a clear error instead of running something else.
Streams everything it does
Every message, tool call, file change and result is a typed event. Intelligence shows them live in the task and keeps them as the run's transcript, under a readable summary.
Harnesses it runs
| Harness | How Hands talks to it | Notes |
|---|---|---|
| Claude | Agent Client Protocol | Signs in with a Claude subscription or an Anthropic API key. |
| Codex | Codex app server | Signs in with a ChatGPT account or an OpenAI API key. |
| OpenCode | OpenCode server | Not on Linux Arm. |
| Grok | Agent Client Protocol | Linux x64 and macOS on Apple silicon. |
| Cursor Cloud | Cursor's hosted agents | Experimental. Cursor runs the agent in its own cloud machine. |
Where it runs
Hands runs in the agent's environment: on the machine that runs Intelligence, on an SSH host you add, or in a sandbox. It supports:
- Linux on x64 and Arm, with glibc 2.39 or later;
- macOS on Apple silicon and Intel.
Intelligence checks the environment before it chooses Hands for an agent. Where Hands cannot run a harness, the agent keeps the earlier runner, and the agent's settings say why.
Hands and Intelligence
Intelligence and Hands split the work:
| Intelligence | Hands |
|---|---|
| Wakes the agent for a task, a comment or a routine | Starts or resumes the harness session |
| Holds the agent's role, permissions and budget | Runs the turn and streams what happens |
| Approves governed actions and records every change | Sends each tool call back for a decision |
| Keeps the summary, transcript and cost on the task | Saves checkpoints so the run can continue |
Every run on Hands is an ordinary Intelligence run: it counts against budgets, shows in Costs and keeps its transcript on the task.
Hands ships with Intelligence and updates with it: every Intelligence release comes with the Hands release it was tested with, so the two never drift apart.
Next steps
- Run an agent on Hands with Claude or Codex.
- Use Hands with Intelligence: move agents, steer runs and read what they did.