Give local models the support they need.A model server gives you a model. Gezel surrounds it with tested plans, tools, knowledge and quality checks, so its work comes close to frontier quality.
Free and open source under the MIT license, on npm and Docker. Use it
forever on your own hardware: no sign-ups, sales calls, or token budgets.
Desktop app the workshop windowgezel CLI terminals and scriptsYour app through gezel-app-sdk
one local, authenticated API
gezeldthe Gezel service, on your computer
Projects
Crew
Craftbooks
Scripts and tools
Knowledge
AI Apps
one provider layer
On this computer llama.cpp · MLX · DwarfStar · Device app modelsIn the cloud Claude · Codex · OpenAI · Copilot
Tested on real work
We give local and cloud models the same real jobs, on hardware we name, and publish every result. Each test asks what Gezel’s support is worth.
How close does a local model get to the frontier?
37 of 41 tasks passed by Qwen 3.8 27B on one Mac, with no per‑token bill.
Claude Sonnet 5.5 and GPT-6 Luna passed all 41 through their APIs. Same tasks, local run on a 128 GB M5 Max, October 11, 2026, one run per task. Every round →
Tested plans
Each of 300+ craftbooks breaks a job into steps, with a quality check at the end. That structure is what lets a model that fits on a laptop finish real work. Craftbooks
Knowledge the model lacks
Offline Wikipedia shelves, and catalogs you compile from your own documents, searched on the device so a small model can look things up and cite them. How knowledge works
Results you can check
Four published task sets, run on named hardware. A task run fewer than three times shows as a count, never a percentage, and failures caused by the machine are set aside, not blamed on the model. How we test models
Design partners
Bringing Gezel into your organization?
We’re working closely with a small number of teams whose AI work has to stay on their own machines. Tell us about one workflow, and we’ll help you get it running.
The gezel command drives the same service the desktop
app uses. Start craftbooks, send one-shot prompts and wait for the
results from a terminal, a script or a server.
Install @bendyline/gezel-cli with Node.js 24 or newer. You don’t need to install or open the desktop app.
# Install once$ npm install -g @bendyline/gezel-cli
# Start a craftbook in this folder’s project and wait$ gezel do summarize-long "Summarize notes.txt for the board" --wait
# Set any parameter by name$ gezel do powerpoint-deck "A deck about Delft" audience=investors
# One-shot prompt, reply on stdout$ gezel run "Draft a friendly reminder about Friday’s deadline"
Run any craftbook as a task
gezel do starts any of 300+ tested plans in the folder’s project. Plain words become the request and key=value sets parameters. Add --wait --json for one result and an exit code a script can branch on.
One-shot prompts
gezel run sends a prompt and prints the reply. It uses the service that’s already running, or starts one for that single call and shuts it down afterwards.
No desktop app required
The npm package works on its own, including on first use and on a server. It finds or starts your own background service, and gezel start --web opens the full interface in a browser.
Watch and steer the crew
List, inspect, pause and resume tasks across every project. gezel mode sets how active AI may be, from read-only to full play, and gezel stop --keep-running is the emergency brake.
Models, engines and media
See which catalog models fit this computer, pull one and make it the default, or export it as a portable .gezmodel file. Make images, video and narration from the terminal too.
Build knowledge catalogs
Compile a folder of Markdown into a portable .gezk catalog with keyword and semantic search. Search it offline, then install it so your crew can cite it.
Connected apps
Add local AI to your app
Anything that speaks the OpenAI chat API can use the models on
this computer. Start with one HTTP call. When you ship, the SDK
adds model downloads, consent and a key the person can revoke.
The port is the one Ollama uses, so tools that look for Ollama find Gezel too.
It takes no key, so it stays off until you turn it on, here or in
Settings → Integrations. Any model name works: your Meester answers,
on the model your chats use.
# 1. Install, and download a model that fits this computer$ npm install -g @bendyline/gezel-cli
$ gezel run --download "Say hello"# 2. Open a plain-HTTP port for other programs$ gezel integrations ollama on
# 3. Ask, from anything that speaks the OpenAI API$ curl http://127.0.0.1:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model": "gezel", "reasoning_effort": "none",
"messages": [{"role": "user",
"content": "Say hello in five words."}]}'
Then ship it with the SDK
Give a Node.js or Electron app the same models with consent built
in. Gezel takes care of model downloads and the inference service,
and your app keeps its own interface.
Install @bendyline/gezel-app-sdk in your app. The Node entry needs Node.js 24 or newer.
import { connect } from'@bendyline/gezel-app-sdk';
// Where your app keeps its token.// Use the OS keychain in a real app.const tokens = new Map();
const tokenStorage = {
save: (appId, token) => void tokens.set(appId, token),
load: (appId) => tokens.get(appId) ?? null,
delete: (appId) => void tokens.delete(appId),
};
// The person approves this app once, in Gezel.const app = await connect({
appId: 'acme.notes',
appName: 'Acme Notes',
scopes: ['openai'],
tokenStorage,
});
const models = await app.models();
const stream = await app.chat({
model: models.data[0].id,
messages: [
{ role: 'user', content: 'Give this note a short title.' },
],
stream: true,
});
for await (const chunk of stream) {
process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}
OpenAI-style APIs
List models, chat with or without streaming, create embeddings, and make sure a model is installed and warm. The list can include the person’s helpers, each with its own character and tuned model.
Consent built in
Ask for the narrowest scope and the person approves it in Gezel. Access to projects, knowledge or images also shows a code in your app to type into Gezel. Any connection can be revoked in Settings → Integrations.
With or without Gezel installed
connectOrHost uses the person’s Gezel when it’s running and starts a private one inside your app when it isn’t. Models they already have are reused, and a bundled .gezmodel lets a first run work offline.
Your tools, offered to the crew
Register tools whose handlers run in your app. Helpers see them beside Gezel’s own, arguments are checked against your schema first, and every call shows up in the transcript and History.
The full product API
Pair the SDK with @bendyline/gezel-client to work with projects, tasks, chats and scripts through a typed client, while the SDK keeps discovery, pinned TLS and the scoped token.
Just the models, if that’s all you need
@bendyline/gezel-inference runs on-device engines such as llama.cpp and MLX in your own process, with no projects, chats or tools attached. DocBlocks uses it for writing and review.
AI Apps
Build apps that live in Gezel
Package a page, scripts, a crew and craftbooks into one app that
installs into a project. A language trainer, a research room or a
board game can each feel like its own application, with the whole
workshop underneath.
Build it with the gezel app commands, by hand, or with an AI agent.
# Scaffold a source folder that already validates$ gezel app new my-app --with-page
$ cd my-app
# Every finding at once, then a package$ gezel app validate .
$ gezel app pack . # → my-app-1.0.0.gezapp# Review and install it, then make a folder its project$ gezel app add my-app-1.0.0.gezapp
$ cd ~/reading-circle && gezel app apply my-app
One package, every part
A project type ties it together: setup questions, the crew, craftbooks, scripts, seed data, schedules and an Output page. Use only the parts your app needs. A page and a folder are already an app.
An interface in plain HTML
The Output page is ordinary HTML, CSS and JavaScript. Gezel provides window.gezel to read the files it declares, watch them change, query indexed tables and call declared tools, and the page follows Gezel’s theme.
Scripts with declared powers
Actions and checks are TypeScript built on @bendyline/gezel-sdk. Each script lists the capabilities it needs and runs in Gezel’s sandbox. Pages have no raw write API, so every change goes through a declared tool.
A crew and repeatable work
Give the app helpers with a working character each, and craftbooks that turn a job into checked steps. Or reuse any of the 52 characters and 300+ craftbooks in the catalog.
Validate, pack and share
add shows the publisher, contents and dependencies before anything installs, and never runs what’s inside. Share a .gezapp privately, serve its page as a mini-site, or contribute it to the public collection.
Made for AI agents to build
Live JSON Schemas, validate --json with stable rule ids, and three example apps of graded size let an AI agent build an app with the same loop a person uses.
Build an app with your AI agent
Paste this into Claude Code, Codex or Cursor, and fill in the first line. Everything the agent needs is on one page, for people as much as for agents.
Prompt
Build a Gezel app for [who it is for, and the job it helps with].
First read https://gezel.com/docs/build-a-gezel-app.md and follow it.
It has the working loop, the rules, and every guide you need.
Install the Gezel command line with npm install -g @bendyline/gezel-cli;
gezel app guide prints the same page for the version you installed.
Add --download to any gezel command that needs a model, so it downloads
what this computer needs instead of stopping to ask.
When the app validates, tell me what it does, which files it owns,
what it can read and change, and how to install it.
The whole of Gezel in one image, with every engine for local models already inside. What it downloads is models: the one you choose, and small ones for searching files and reading pictures, plus a browser for tasks that visit websites.
Your workshop in a browser
Start it, open the link in its log, and create your account. Add the people you trust, each with a sign-in of their own.
docker run -d --name gezel -p 127.0.0.1:6230:6230 -v gezel:/gezel ghcr.io/bendyline/gezel
Local AI for your other apps
Make a key, then point any OpenAI-style client at http://localhost:6230/v1. Every key shows in Integrations, where you can revoke it.
Run one craftbook on the folder you are in, and collect what it made in a folder beside it. If the workshop container is already running, use docker exec gezel gezel do … instead: Gezel runs once per volume.
docker run --rm -v "$PWD:$PWD" -w "$PWD" -v gezel:/gezel ghcr.io/bendyline/gezel do summarize-long "Summarize these notes for the board" --out ./gezel-out
NVIDIA and AMD or Intel graphics cards each have an image. On GitHub's registry and Docker Hub. Gezel in Docker →
More building blocks
Every package is open source and semver-versioned, and needs Node.js 24 or newer. Install the one at the top of your use case; npm brings in the rest.
The service listens only on the person’s own machine, over an encrypted local connection whose credential changes every time it starts. In a container it answers only the people signed in and the apps given a key. API keys go straight to their provider. There’s no Gezel server to pass them through. The security model
Consent people can see
Each app asks for the narrowest scope it needs, and the person approves it in Gezel. Wider access also shows a code in your app for them to type in. Every connection can be revoked in Settings → Integrations. Integrations
Code that stays in bounds
Scripts declare the capabilities they use and run in a sandbox, behind an operating-system wall where one is available. App pages change files only through declared tools, so every change stays auditable. The script SDK
Start building tonight.
Free and open source, for macOS, Windows and Linux.