Varin

Everything around the model, ready out of the box and customizable in depth.

v0.9.32WindowsmacOSLinuxSelf-host with Docker

01 · Harness

The same model goes further in Varin.

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 finish longer, more complex tasks.

    • Readable outputTrimmed by structure, originals a page away
    • Prepared aheadContext is tidied in the background
    • Exact countsLocal tokenizers, calibrated by real usage
    • MemorySee what it remembers, and change it
    • Tools on demandCommon tools at hand, the rest loaded when needed
    • Self-curated contextWrites the summary, keeps key originals
    • MCP, two waysExposed directly or discovered on demand
    • Isolated copiesTeammates edit code in their own copy
    • TeamworkAssign, talk, hand over, report
    • ModelDoes the thinking. Your pick.
    • Durable runsEvery step recorded, resumed after restarts
    • Questions don’t blockOther work goes on while it waits for you
    • Multi-model runsOne task, several models, side by side
    • Goals and follow-upsBudgeted goals that resume when conditions are met
    • No blind replaysUnclear outcomes stop for a check
    • Automatic retriesBackoff built in, rules you can change
    • Scripted toolsOne script, many tools, a visible call tree
    • File timelineRoll back by turn, undo the rollback
    • Permission rulesAllow, ask or deny per tool

02 · Ready, and yours

Good defaults. Deep customization.

Ready out of the box

Add an API 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

Deep customization

Adjust how each part works without writing code.

  • 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 configurable retry policies

Use your own API key.

Keys stay on your own Host, requests go straight to the providers you configure, and usage is recorded per channel and model, turn by turn.

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

03 · Four ways to work

A mode for code, research, office work and the rest.The mode decides which tools the agent starts with and which teammates help out.

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 all the tests pass.”

ResearchRESEARCH

Investigate, compare explanations, develop experiments

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

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

OfficeOFFICE

Documents, data, browser and computer tools

Works directly with Word, Excel and PowerPoint, plus the browser and the apps on your computer.

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 for the jobs that come up every day.

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

04 · Team

One task, split across several agents.

The lead agent breaks the task down and assigns the parts: a Worker writes the implementation, a research agent gathers 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 the agent that assigned the work. Follow the discussion 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
  • Each member reports back when done

05 · Bots

Bots that stay on the job.

A bot 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 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

06 · Extensions

Our workbenches are extensions too.

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

What makes up an extension

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, each with its own extension points

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 version 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 stay contained

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

Changes are recorded by turn. Roll back any time.

Every edited file lines up on a timeline, turn 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

Computer, browser, phone. One 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

Start with your first task.

The code is open source. Your data, models and extensions stay in your hands.