Announcing LFM3 Workspace v0.1.1: Run Liquid AI's LFM3 Models Fully Locally

Why a Local Cowork Harness Matters

Most AI assistants in 2026 still assume your work belongs in someone else's datacenter. You upload the documents, accept the telemetry, manage the per-seat subscription, and hope the vendor's privacy policy holds. For casual questions that's fine. For real work — the folder of client notes, the drafts you're being paid to write, the images you can't paste into a web form — it's a dealbreaker. This blog has covered the privacy gap between cloud and local AI and what on-premise deployment actually requires before.

The local side has the opposite problem. Runtimes like Ollama and llama.cpp are excellent, but they're developer-shaped: terminals, model files, config flags. And the GUIs built on top of them are mostly chat shells — a text box, a model picker, and no story for what happens when the model touches your files.

LFM3-Harness fills that gap. It's an independent, community-built, MIT-licensed desktop harness around Liquid AI's LFM3 model family — not a Liquid AI product, but an app built to make those models genuinely usable for everyday work. Its premise is simple: an app that behaves like a careful coworker. It reads the folder you point it at, summarizes and drafts, inspects images, takes voice messages — and before it changes a single file, it shows you the exact diff and waits for your approval. (For the background on the models themselves, start with LFM Models: Liquid Foundation Models Explained.)

What LFM3 Workspace Actually Is

The primary interface is a conversation. You type a message, attach an image, or record a voice note. The models respond by doing work: mapping a folder's structure, finding and summarizing files, tracing which notes relate to which, inspecting a screenshot, or proposing a Markdown report or a file edit. Conversations persist in a local chat.db, so closing the app doesn't lose your thread, and a Stop button cancels streams and any pending approvals immediately.

Two design rules run through everything. First, every tool call is visible — you see what the app did, not just what it said. Second, all writes sit behind exact-diff approval: the app proposes a precise change to a file, and nothing executes until you accept it. It never reports unverified work as finished.

The tools themselves are workspace-confined: list_files, read_file, search_files, and the write/edit operations can only touch the workspace folder you chose — nothing else on your disk is reachable. Image attachments (PNG, JPEG, WebP, GIF up to 20MB) go to the vision model; voice messages are transcribed locally, and replies can be synthesized back as speech.

The Four-Model Team

LFM3 Workspace doesn't ask one model to do everything. Each turn is routed to whichever small, specialized model fits the job — the same specialist pattern behind multi-agent systems, except all the specialists live on your CPU. Here's the roster:

Why small models instead of one big one? Because they have to fit a CPU budget. A 1.7B–2B class model leaves room on an 8GB machine for the runtime, the UI, and your actual work — see what 8GB vs 16GB RAM actually fits. And because the decision model gates every step — which tool to call, whether the evidence is good enough — you get tool calling with a checkpoint, not a free-running loop.

Verified Tasks: Work That Certifies Itself

Chat is honest about being a conversation. But when an AI touches files, "it said it's done" isn't good enough — that's the failure mode behind most disappointing agent projects, and it's why agents are only worth building when success is measurable.

Verified tasks are the app's answer to that failure mode. A mission runs against a frozen acceptance contract — the success criteria are written down before the work starts and don't move mid-run. Independent deterministic checks grade the output; the model never grades itself. And the checks consume provenance-bound evidence: proof tied to where the claim came from, not a summary of vibes. If a check doesn't pass, the mission doesn't report done — full stop.

Three semantic missions stay human-review-only by design, because no trustworthy deterministic check exists for them yet. The app shows an honest "needs your review" rather than a confident green checkmark. Operation is also bounded: context limits and turn boundaries stop a mission from wandering, and every mission keeps its workspace separate.

What's New in v0.1.1

v0.1.0 was Windows-first. v0.1.1, released November 1, 2026, makes the app a genuine cross-platform desktop citizen. The headline is native Linux support — and underneath it, a batch of reliability work that matters more than it sounds:

Every release asset is listed below in the download section, including a 22.2 MB headless CLI archive for Linux if you want the missions without the desktop UI.

Under the Hood

The stack: a Rust core engine, a React/TypeScript UI, Tauri 2 as the desktop shell, and pinned llama.cpp processes for inference — pinned, so the behavior you get today is the behavior you get next month. SQLite backs the chat history and the journals that Verified tasks write. The engine spawns external llama.cpp processes rather than embedding inference in the UI process, which is what makes the deterministic shutdown and process containment from v0.1.1 possible. If you're weighing runtimes yourself, the trade-offs are laid out in Ollama vs llama.cpp.

Models are managed in the app: you pick what you need and download it through the UI. All four roles plus a workspace fit in roughly 4.9GB of disk. Inference is CPU-only in this release — deliberately, so the app works on any x64 laptop without a GPU. That's a real speed trade-off, and it's covered honestly in the limitations below.

Privacy is structural, not a policy: no account exists, no cloud calls are made, no telemetry is collected, and after setup the app runs completely offline. Your conversations live in chat.db on your disk.

How to Install LFM3 Workspace v0.1.1

Requirements first:

Windows (x64)

1. Download LFM3.Workspace_0.1.1_x64-setup.exe (15.2 MB) from the release page — ideally verify it against SHA256SUMS.txt.
2. Run the installer. Because it's unsigned, SmartScreen will warn you; choose "More info" → "Run anyway" if you're comfortable.
3. Launch the app and download the models you want from the model manager. For chat, you need the text role at minimum.

Linux (x64)

1. Install WebKitGTK 4.1 and GTK 3 from your distribution's repositories if they're not already present.
2. Either install the .deb with your package manager (for example sudo apt install ./LFM3.Workspace_0.1.1_amd64.deb), or download the .AppImage, make it executable with chmod +x, and run it.
3. Launch the app, pick your models, and go. Your data lands under $XDG_DATA_HOME/LFM3Harness.

First run

Start in Chat: point the workspace at a folder of real files and ask it to map the structure or summarize a document. Attach an image to see the vision model work; hold the mic button to send a voice message. Approvals appear as exact diffs — accept or reject each one.

If you prefer the terminal, the headless CLI exposes the same engine:

# health-check the installation
lfm3-cli doctor

# list missions and probe local models
lfm3-cli missions
lfm3-cli models --probe

# run an agent-style job against a workspace
lfm3-cli job --goal "Read notes/ and write out/report.md, one section per note" --workspace ./demo --minutes 30 --events -

# or a plan-first general task
lfm3-cli task --goal "Summarise demo/notes.md into out/summary.md" --workspace ./demo

The Honest Limitations

This is an experimental early release, and anyone evaluating it should know exactly where the edges are:

• Unsigned packages. The Windows installer and the Linux packages aren't code-signed, so your OS or browser will warn you. Check the SHA256 sums against SHA256SUMS.txt before trusting them.
• CPU-only inference. No GPU path in this release. Chat and file work are comfortable; long batch jobs are slower than a GPU build would be.
• Three missions are human-review-only. The semantic checks don't exist yet, so the app refuses to auto-certify them — by design.
• Linux voice fallback. Linux has no system-voice fallback, so audio output depends on the local synthesis path.

None of these are hidden: the release notes state them, and the app states them where they apply. That's the point of a harness — trust is earned by showing work, including its limits. The project is MIT-licensed on GitHub, and issue reports genuinely shape the roadmap.

Frequently Asked Questions (FAQ)

What is LFM3 Workspace?

LFM3 Workspace is a fully local, chat-first desktop app for running Liquid AI's LFM3 model family on your own machine. It is built with Rust, React, Tauri 2, and pinned llama.cpp, and offers two surfaces: open-ended Chat and Verified tasks with deterministic checks. It needs no account and makes no cloud calls.

Does LFM3 Workspace need an internet connection or an account?

Only for setup. You download the installer and the models once; after that the app runs completely offline. There is no account, no cloud calls, and no telemetry — conversations persist in a local chat.db on your machine.

What hardware do I need to run it?

A Windows 10/11 x64 machine or a Linux x86_64 machine with a recent glibc. Inference is CPU-only, so no GPU is required: 8GB of RAM covers chat with the text role, and about 4.9GB of disk fits all four model roles plus the workspace. Linux desktop additionally needs WebKitGTK 4.1 and GTK 3.

How is it different from Ollama or a local chat GUI?

Ollama and llama.cpp are model runtimes; most GUIs are chat shells on top of them. LFM3 Workspace is a harness: it routes each turn to a specialized model, confines tools to a workspace folder, shows every tool call, keeps file writes behind exact-diff approval, and never reports unverified work as finished.

What are Verified Tasks?

A second surface for machine-certified work. Each mission runs against a frozen acceptance contract with independent, deterministic checks and provenance-bound evidence — the system refuses to mark work finished unless the checks pass. Three semantic missions stay human-review-only by design.

Is v0.1.1 production-ready?

It is an experimental early release. The Windows installer and Linux packages are unsigned, inference is CPU-only (slower than GPU builds), and Linux has no system-voice fallback. For chat, file work, and verified missions it already runs fully offline — try it, and report issues on GitHub.