Veloresearch/impulse

Intelligence with longer memory.

Run any AI model on your own computer, give it a memory of up to 32 million tokens, and use it from chat, voice and every app you have.

_{Made by Velocity, an independent AI company.}

 

_{Offline? Get the full Windows installer.}

Technical report  ·  Release notes  ·  veloresearch.com  ·  X  ·  Hugging Face

_{A real recording on a 6 GB laptop card: the question is looked up, the pages are read, and the answer cites them.}

In 30 seconds

Personalities: one spin

Momentum: 1.4M tokens, one click

_{Sources: every claim checked}

Why Impulse

• One app for running models locally. Download or add a GGUF model, and Impulse chooses 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 Momentum a model works across far more material 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. Impulse does that too, and adds what sits around the model: a memory 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}

Momentum

Momentum is memory for local models: your knowledge, within reach. A model with an 8K-token window works across up to 32 million tokens of your documents, chats and code, on a laptop graphics card. No embeddings, no vector database, nothing leaves the machine.

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.

If you point Impulse at a cloud model, the parts of your material used for a question are sent to that provider.

_{Contexts: a context of 578 source files, opened and searched}

Answer time stays under 0.8 s, from 1M to 32M tokens (median; the build is a one-time text pass):

Measured, not claimed

One laptop: RTX 3060 Laptop, 6 GB, Qwen3.5-4B-Q4_K_M, an 8,192-token window throughout. The full method, the per-task tables and the limits are in the evaluation report (PDF).

Beyond 128K, on the app's built-in ladder with nine of RULER's tasks and five samples per cell. This is a separate benchmark lane, reported on its own and never averaged with the result above:

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: every claim points back to the page it came from}

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.

Diagrams: a flowchart drawn inside the answer	Instant facts: the time anywhere, answered at once
Thinking level: Instant to Max on one slider	Tools: switch tools on and off; the pill follows
Web search: one tap on or off	Answer versions: page between answers with ‹ 1/2 ›
/ commands: type / and a letter narrows it	Drop a file: it joins the chat

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.

Save as: PDF, Markdown or an image	Answer details: what one answer took
@ mentions: attach a file or answer from a memory

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}

Explore the app

Real recordings of a first look around, with no model loaded.

_{Models and Hugging Face: search, filter, and every build checked against your card}

A download: a 610 MB build, picked to fit this card	Your models: memory per chat, and where the layers go
Settings: chat style, memory size and backups	Hardware: the card, memory and engines, live
Connect: one address and key for every app	Apps and Plugins: agents in one click, MCP servers as presets
Studio: images, video and voice, set up in place	Ctrl+K: jump to a setting, a context or a page
Folders: group chats in folders	Find a chat: every chat searched, matches marked

_{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.

Its own cursor. A second pointer shows where it is going and what it is doing. Your mouse stays yours.

You decide how much it may do. Watch only, Ask every time, Ask before risky actions (the default), or Act without asking. It is off until you turn it on.

You can always stop it. Esc, Stop, or moving the mouse into the top-left corner halts it at once. Pause, Take over and Continue hand control back and forth.

• It never types into password fields, always asks before closing unsaved work, and never acts on a window you did not name.
• Choose which screen it works on. Every action is recorded in an activity log.
• It works with the sandbox: take something from the screen, process it in Python, put the result back.

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: one switch, four permission levels, and the screen it works on}

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

_{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.

_{Replay: an answer, token by token, with what it nearly said}

Weights: every layer, brighter where the weights are larger

Shape: how the model is built, as its file describes it

_{Back to top}

Studio, Plugins and Apps

_{Back to top}

The details

_{Load a model: the sheet says what fits your card before it starts}

Find a model: from an empty Studio to the models that run here

Guided tour: it points at each place the first time

_{Back to top}

Make it yours

_{Themes: Dark, Light, Cream and Matrix, applied at once}

Home and the sidebar, arranged your way. Drag widgets by their handles, resize them, add or remove 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 required before the panel opens. Apps keep working with the API key; the password only protects the panel.

Backups and restore. Everything Impulse keeps (chats, preferences, service settings, contexts) in one file you can store anywhere, on a schedule if you like, and restore on a new machine.

Arranging Home: drag, resize, add	Sidebar: your pages, your order
Appearance: themes, accents and fonts	Voice & audio: microphone and speaker, tested in place
On a phone: the same panel, with a floating bar	Data: back up and restore

A window or a browser. Impulse 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}

Install

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

irm https://github.com/Veloresearch/impulse/releases/latest/download/install.ps1 | iex

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

The installer checks the machine before it downloads anything and picks the build that suits it: CUDA where there is an NVIDIA card, Vulkan on Linux where there is any card at all, and the processor build otherwise. It opens the panel when it is done. Updates install from Settings. Removing Impulse means deleting one folder; your models and memories are stored separately.

_{Starting Impulse: the mark, then the panel}

The first start shows you around. Pick a language and a name, choose how much of the app you want to see, and Impulse tells you what this computer can run before you download anything.

Welcome: what it does

Your computer: read before any download

Three steps: to a first answer

_{Back to top}

Use it from the agent you already have

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

		what Connect does
	opencode	adds Impulse as a regular provider in ~/.config/opencode/opencode.json and makes it the model opencode starts with
	Hermes Agent	points ~/.hermes/config.yaml at Impulse as its custom endpoint, keeping your previous model to restore

Not an MCP plug-in and not a bridge: Impulse 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 scripts):

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 any setup, and a coding agent gets one per project: it says which folder it is working in, and Impulse 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 no memory, 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

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

# images
curl http://127.0.0.1:11500/v1/images/generations -H "content-type: application/json" \
  -d '{"prompt":"a watercolor lighthouse at dawn","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}

Built on

Impulse is a router with Momentum behind it. The memory, the routing, the hardware fit, the mesh and the panel are built by Velocity. llama.cpp (MIT) runs the GGUF models, stable-diffusion.cpp the pictures, and Piper and faster-whisper the voice. Their licences ship inside every package.

Every picture and GIF on this page is a recording of the real app with real model output; the contexts are public open-source code.

FAQ

If Impulse is useful to you, a star helps others find it

Impulse and Momentum are made by Velocity, an independent AI company.

veloresearch.com  ·  Impulse  ·  Momentum  ·  Evaluation report  ·  Releases  ·  Issues  ·  @velo_research  ·  [email protected]