Open source · BYOK · AGPL-3.0

One person.A whole team.

The open-source agent and bot workspace for code, research, office work and everything in between. Ready out of the box, customizable all the way down. Bring your own model.

macOS · Linux · Self-host with Docker · Connect from a browser or phone

01 · Team

You set the goal. They split the work.

The lead agent breaks the task down and hands it to teammates: a Worker writes the implementation, a research agent digs up context, a verifier runs the tests. Each member has its own name, avatar and conversation. They message each other, hand over code, and report back to whoever assigned the work. Watch them talk it through in the collaboration panel, and step in whenever you like.

  • Members work in parallel, each in its own thread
  • They message each other directly, not only through you
  • Code handoffs come with diffs, file by file
  • Every member reports back when done

02 · Four ways to work

Four ways to work. One workbench.A mode decides which tools are within reach and who is on the team.

CodeCODE

Tools for working with code

Read and change code, run commands, open terminals. Every edited file is checkpointed by turn, so you can roll back any time.

WorkerResearch agentVerifier
“Refactor the login module and ping me when the tests are green.”

ResearchRESEARCH

Investigate, compare explanations, develop experiments

Search OpenAlex and Semantic Scholar, read papers and PDFs, and push an experiment forward step by step.

WorkerResearch agentResearch partner
“Find the last two years of papers on this and build a filterable comparison table.”

OfficeOFFICE

Documents, data, browser and computer tools

Word, Excel and PowerPoint, plus the browser and the apps on your computer. It works with them directly.

WorkerResearch agent
“Export last month’s orders into an Excel sheet with charts.”

GeneralGENERAL

Balanced tools for everyday work

Look things up, write, or build a small interactive tool. Whatever the day brings.

WorkerResearch agent
“Compare these three cameras and make a chart I can tweak.”

03 · Bots

A bot of your own.

A bot is an agent that stays on the job. It has its own name, personality, model and working directory, keeps several pieces of work moving, and can be given a computer desktop. You can see everything it remembers, correct it, or have it forget. Put it to sleep and its work is suspended; wake it and it picks up exactly where it left off.

  • Its own name, instructions, model and folder
  • Several pieces of work in parallel
  • Memory you can see, correct and erase
  • Sleep and wake without losing work
NameMallowModelDefaultFolder~/bots/mallow
  • Weekly dependency checkWorkingSuspendedResuming…
  • Tidy up paper notesWorkingSuspendedResuming…
  • Reply to review commentsWaiting for youSuspendedResuming…
Weekly reports go in a tableCorrectForgetNever push straight to mainCorrectForget

04 · Harness

The model thinks. The harness goes the distance.

The model sits in the middle. Every cell around it is something Varin prepares for it: tools, context, execution, collaboration and recovery. Put the same model in, and it can carry longer, more complex work.

05 · Ready, and yours

Ready on day one. Yours all the way down.

Ready out of the box

Add one key and start. Everything else is already in place.

native tools
~80
work modes
4
official workbenches
4
bundled language servers
6
native model protocols
8
theme families, light and dark
21
interface languages
10
languages of offline dictation
~100

Customizable all the way

No code needed to make every part your own.

  • Give any preset agent a new model, instructions or tools, or create your own
  • Separate models for titles, context curation, planning, images and embeddings
  • Editable system instructions and memory
  • Skills from .claude and .agents folders, installable from a Git repo
  • MCP servers exposed directly or discovered on demand
  • Per-tool permission rules and your own retry rules

Bring your own model.

Keys stay on your own Host. Usage is recorded per channel and model, turn by turn. No middleman.

  • OpenAI Responses
  • OpenAI Chat
  • Anthropic
  • Gemini
  • Vertex AI
  • Azure OpenAI
  • Bedrock
  • Mistral
  • Alibaba Model Studio
  • Zhipu
  • StepFun
  • Ollama
  • LM Studio
  • Any compatible endpoint

06 · Extensions

Even our workbenches are extensions.

The Agent, IDE, Research and Bot workbenches, along with the browser, Office, computer control and language servers, are all registered in one extension catalog through the same contracts you use. Any of them can be turned off, and a workbench can be replaced entirely.

What an extension looks like

Hover a file on the left to see the matching part of the manifest.

examples/extensions/agent-authored-panel/
varin.extension.json

The contract. Discovery, activation, permission review and tool schemas all read it, so an extension is discoverable without running any code.

IdentityEntry pointsServices and toolsUI contributions
package.json

Plain npm metadata. Its version matches the manifest and it can declare build entry points.

host.js

Host side: tools, model protocols, context algorithms and agent policies. Here it runs brokered, in its own child process.

surface.cjs

Interface side: panels, editors, even a whole workbench. Declarative, managed, or isolated in an iframe or worker.

panel.css · panel.svg

Assets. Icons, styles or bundled executables, all resolved inside the immutable package.

{
  "schemaVersion": 1,
  "id": "example.agent-authored-panel",
  "version": "1.0.0",
  "engines": { "varin": "*" },
  "entrypoints": {
    "host": { "file": "host.js", "mode": "brokered",
              "activation": ["service-request"] },
    "surfaces": [{ "id": "panel", "file": "surface.cjs", "mode": "managed",
      "supports": ["web", "desktop"], "activation": ["application-startup"] }]
  },
  "provides": { "services": [{
    "id": "example.agent-authored-panel.count", "version": 1,
    "tool": { "name": "authored_text_count", "completion": "result",
              "operation": "read", "inputSchema": { … } }
  }] },
  "contributions": [{
    "id": "example.agent-authored-panel.summary", "kind": "panel",
    "entrypoint": "panel", "supports": ["web", "desktop"],
    "placement": { "slot": "workbench.secondary.after", "order": 20 }
  }]
}
import { defineHostExtension, provideTool } from '@varin/extension-sdk';
import manifest from './varin.extension.json' with { type: 'json' };
 
export default defineHostExtension({
  activate(context) {
    // The same service the manifest declares: discovery and activation read one description
    provideTool(context, manifest.provides.services[0], async (input, call) => {
      // Call a built-in tool from the new one; the original receipt is kept intact
      const memory = await call.tools.invoke({
        callId: 'memory', name: 'memory', arguments: input.memory,
      });
      return { memory };
    });
  },
});

Manifest excerpted from examples/extensions/agent-authored-panel with long schemas elided; host.ts simplified from nested-tools.

Three layers, many places to plug in

The interface holds no privileges. Privileged work stays on the trusted side.

SurfaceINTERFACE

Gets typed callbacks and mount points, nothing more. Swapping a shell or an editor never buys extra permissions.

DeclarativeManagedIsolated iframe / workerNative

Application HostHOST

Tools, language servers, debuggers and test runners live here. A brokered extension has its own process and lifecycle; if it fails, only it is reclaimed.

Brokered child processNative

Rust runtimeRUNTIME

Pins the exact implementation for every call. Credentials, model requests, execution records and recovery stay here.

Tool directoryModel adaptersComposition registry

UI contributions16 kinds

Whole workbenchTransition sceneViewEditorPanelSidebarPageSettings pageCommandKeybindingMenu itemComposer actionStatus itemSession badgeMessage rendererTool renderer

Agent contractsVersioned

Toolsvarin.models@1varin.context.fragments@1varin.context.budget@1varin.context.compaction@1varin.retrieval.plan@1varin.agent.policy@4Run activity observers

WorkspaceRun by the Host

Language supportDebug adaptersTests

Why it is built this way

However many extensions you add, the workbench stays stable and under your control.

One manifest is the contract

Discovery, activation and review all read the same varin.extension.json. An extension can be found, shown and checked before a line of its code runs.

Requesting is not granting

Permissions are approved per version and per layer. An upgrade never inherits new permissions, and revoking takes effect at once.

Staged, then published together

Everything in an update takes effect at the same moment. If it fails, the previous generation stays; nothing is half installed.

Updates never cut work short

Calls already running stay on the implementation they started with. Only new calls use the new version.

Failures have edges

Brokered extensions run in their own child process, so a failure only reclaims that extension. If the chosen workbench cannot start, a recovery shell takes over.

Agents can write, not approve

An agent can read contracts, write an extension and install it, but a first install is always disabled until you review it.

SDKCLI: init · check · build · test7 project templates16 examplesConformance test kitInstall from the repository until the SDK is published.Authoring guide →Browse examples →

07 · Control

Let go, keep control.

Edited files line up on a timeline by turn. Roll back in one step, and undo the rollback too. Files you changed by hand are never overwritten, and an action with an unclear outcome is never quietly repeated.

08 · Anywhere

Pick up from anywhere.

Desktop, browser and phone all connect to the same Varin. Pair with a QR code; away from your network, an end-to-end encrypted relay carries the connection without seeing your content.

Open source · AGPL-3.0

Open source. Yours.

Your code, your data, your models, your extensions.