What's new in 0.1.1 Preview 3 - your local model can now use your computer, by text or by voice

• Computer use. The model opens apps, clicks, types and fills in forms. Four permission levels, off until you turn it on, and Esc, Stop or the top-left corner halts it at once. More
• The island. A small bar at the top of the screen for a quick chat, your history, voice, contexts and live activity. Hidden until you need it. More
• Talk drives the computer. Say a task, interrupt at any time, answer permission questions with "yes" or "no".
• Writing in chat. Instant typing in long chats, a draft per chat, @ to attach a file or pick a context, / commands, and a token counter as the window fills. More
• Voice & audio settings. Choose and test your microphone and speaker; input volume, noise suppression and echo cancellation.
• Starting VLS. Opening it always shows its window; starting with Windows stays in the background.

Computer use and the island are Windows only for now. Full notes: VLS 0.1.1 Preview 3 · all releases

Contents

Why VLS

• One app for running models locally. Download or add a GGUF model, and VLS picks how it runs on your graphics card. Chat, voice, pictures and an OpenAI-compatible API on one address, in one install, with a panel that explains itself.
• More than the model's window. With Velocity Context a model works across far more text than its window holds: add a folder, a repository or a year of notes once, and every question can reach all of it - up to 32M tokens.
• Private by construction. No account, no telemetry, no Docker. The only outbound requests are the ones you ask for.

Most local runners load a model and give you its window. VLS does that too, and adds what sits around the model: a context far larger than the window, tools the model can use, a computer it can operate with your permission, and a way to see how it wrote each answer.

_{Back to top}

Install

One command. No account, no sign-in, no telemetry, no Docker.

Windows - download VLSSetup.exe, or:

irm https://github.com/Veloresearch/velocity-local-services/releases/latest/download/install.ps1 | iex

Linux - download the x64 build (a Vulkan build is beside it), or:

curl -fsSL https://github.com/Veloresearch/velocity-local-services/releases/latest/download/install.sh | sh

The installer looks at the machine before it downloads anything and takes the build that suits it - CUDA where there is an NVIDIA card, Vulkan on Linux where there is any card at all, the processor otherwise - and opens the panel when it is done. Updates install themselves from Settings. Removing it is deleting one folder; your models and memories live somewhere else.

_{Back to top}

Velocity Context

A model's window is a hard limit paid for in memory. Velocity Context gives the model something to reach into instead of a bigger window: you add material once - a folder, a repository, your notes, or simply the conversation as it happens - and every question after that can reach all of it, up to 32M tokens.

• Not RAG. No embedding model, no vector database, no chunk size, no second service to run.
• Counted in the model's own tokens. Sizes are measured with the loaded model's tokenizer, so what you see is what the model sees.
• On your disk. A context is a .mfyc file you own, built in seconds, outliving any model you load.
• Explainable. Every answer carries a receipt with the exact text the model was given.
• Flat cost. Thirty-two times the material, the same half second.

How it was measured, what the controls were and where the results stop are in the technical report (PDF, 14 pages). The method itself we keep to ourselves.

Measured, not claimed

One laptop: RTX 3060 Laptop, 6 GB, Qwen3.5-4B-Q4_K_M, an 8 192-token window.

NVIDIA's RULER, on their harness, nothing underneath it modified:

Beyond 128k, on our own ladder with the same task definitions - reported separately, never averaged in:

The per-task tables, the samples per cell and the parts that do not flatter us are in the technical report. Every benchmark can be run on your own machine from the panel.

_{Back to top}

Chat

Text, photos and files, voice with live transcription, and a model that looks things up before it answers.

Search first, with sources. A question about a part number, a price, a datasheet or anything recent is searched before the model writes a word. You watch the pages being read, and every claim in the answer points back to its source.

Exact maths. A built-in calculator works with units, constants and radio and circuit formulas, and shows every step. The model does not do arithmetic in its head.

Drawings for electronics. Schematics are checked before you see them: every pin connected, every value in range. Pin-outs, wiring diagrams and antenna aiming are drawn the same way, and a schematic exports to KiCad.

A Python sandbox. The model writes and runs Python in the page - with numpy, pandas and matplotlib, and no internet needed - and the files it makes appear as cards you can open or save.

Everything an answer needs around it. Save any answer as PDF, Markdown or an image. See what it cost: time to first words, writing speed, tokens read and written, and how much of the window it used. Find anything in a long conversation with Ctrl+F.

Enter sends, Shift+Enter starts a new line, Esc stops, ↑ edits your last message. Long pasted text becomes a chip with its size in tokens.

_{Back to top}

Computer use

Your local model can open apps, click, type and fill in forms. It reads each window's buttons and fields directly instead of guessing from pixels, and falls back to a screenshot for apps that do not describe themselves.

• It never types into password fields, always asks before closing unsaved work, and never acts on a window you did not name.
• Pick which screen it works on. Every action goes into an activity log.
• It works with the sandbox: take something from the screen, process it in Python, put the result back.
• Voice drives it too: say a task in Talk, interrupt at any time, answer approvals with "yes" or "no".

Measured. Tested with Qwen3.5-4B on Notepad and Calculator tasks: 4 of 4 passed. Reading a window takes 40-120 ms, and an action takes about half a second.

Computer use is new and Windows only. Start with Ask before risky actions, and check what matters.

_{Back to top}

The island

A small bar at the top of the screen, hidden until you need it. Chat without opening VLS, pick up a conversation, talk, choose a context, or watch what VLS is doing.

Open it by holding the pointer at the top edge of the screen, pressing the shortcut (Alt+Space by default, changeable in Settings), or dragging a file to the top of the screen. It hides in full-screen apps and games.

_{Back to top}

Look inside the model

How the last answer was written, one token at a time: what the model chose, how sure it was, and what it nearly said. Then the model itself - every layer, read straight from its file.

_{The weight pictures above are drawn from sample data for this page; in VLS they come from the model you have loaded.}

_{Back to top}

Studio, Plugins and Apps

Use it from the agent you already have

Open Apps in the panel and press Connect beside the agent you use:

Not an MCP plug-in and not a bridge: VLS is the model provider itself, the same way a cloud API would be.

The next time the agent starts, it is talking to the model on your machine. Disconnect removes exactly what Connect added; nothing else in those files is touched, and a backup is kept the first time.

For anything else that speaks the OpenAI API - Continue, Cline, LangChain, your own script:

Base URL   http://127.0.0.1:11500/v1
API key    anything (none is needed from this computer)
Model      velocity  (or any name - it reaches the loaded model)

What the agent remembers. Every application gets its own memory without anyone setting it up, and a coding agent gets one per project - it says which folder it is working in, and VLS keeps that project's memory apart from the others. A new chat in the same project picks up where the last one left off; a different repository starts clean. Each app can be switched to one shared memory, or to remembering nothing, on its card.

One address for everything

# chat
curl http://127.0.0.1:11500/v1/chat/completions -H "content-type: application/json" \
  -d '{"model":"velocity","messages":[{"role":"user","content":"hello"}]}'

# speech - any installed voice, or the default for OpenAI voice names
curl http://127.0.0.1:11500/v1/audio/speech -H "content-type: application/json" \
  -d '{"input":"Hello from this computer.","voice":"en_US-ryan-high"}' -o hello.wav

# listening
curl http://127.0.0.1:11500/v1/audio/transcriptions -F [email protected]

# pictures
curl http://127.0.0.1:11500/v1/images/generations -H "content-type: application/json" \
  -d '{"prompt":"a small orange cube with a face, pixel art","size":"512x512"}'

from openai import OpenAI
client = OpenAI(base_url="http://127.0.0.1:11500/v1", api_key="local")
print(client.chat.completions.create(model="velocity",
      messages=[{"role": "user", "content": "hello"}]).choices[0].message.content)

From another machine on your network the same address works with the key from the panel's API page.

_{Back to top}

Make it yours

Home and the sidebar, arranged your way. Drag widgets by their handles, change their size, add or take off what you do not use. The sidebar shows what you choose, in your order, under your headings.

Themes. Dark, Slate, Light and Cream, or follow the system, with nine accents.

Your account. A name for the greeting, and an optional password that has to be typed before the panel opens. Apps keep working with the API key; the password only guards the panel.

Backups and restore. Everything VLS keeps - chats, preferences, service settings, contexts - in one file you can store anywhere, on a schedule if you like, and put back on a new machine.

A window or a browser. VLS opens in its own window. The same panel works in any browser on this computer at http://127.0.0.1:11500.

_{Back to top}

See it

▶ Watch VLS in action (YouTube) - or take the short tour from Settings › General › Guided tour once it is installed.

Every picture on this page is a capture of the real VLS panel, filled with sample conversations, models and contexts.

Built on

VLS is a router with Velocity Context behind it. The memory, the routing, the hardware fit, the mesh and the panel are ours. llama.cpp (MIT) runs the GGUF models, stable-diffusion.cpp the pictures, Piper and faster-whisper the voice - their licences travel inside every package.

Questions people actually ask

Does anything leave my machine? No. The only outbound requests are the ones you ask for: searching Hugging Face, searching the web from Chat, downloading what you chose, and checking for a newer release. No telemetry, no account.

Do I need a GPU? No. A card makes it faster; the processor build works everywhere.

Which models work? Any GGUF that llama.cpp runs, Piper voices, and diffusion models for Studio.

How can a 4B model with an 8K window answer across 32M tokens? Velocity Context, which is not RAG and not a bigger window. What we measured, and how, is in the technical report; the method itself we keep to ourselves.

Which model should I use for computer use? It was tested with Qwen3.5-4B on a 6 GB card, on Notepad and Calculator tasks. Whatever the model, it is held to the permission level you chose.

Can I turn web search off? Yes, in Chat's Tools menu. With it off, only questions that are plainly about today are looked up, and the Search button always searches.

Does the island work on Linux? Not yet. The island and computer use are Windows only in Preview 3; the rest of VLS runs on both.

Is it open source? No. VLS is free for personal use; companies need a licence - write to [email protected]. See LICENSE.

Is it finished? It is a preview. When you find a rough edge, open an issue - it is the fastest way to get it fixed.

_{Back to top}