⬇ Download OwLLM

Your AI agent workforce on your own hardware — one file, no admin required.

_{Linux: the AppImage needs no install (chmod +x and run — WebKit bundled); the .deb pulls libwebkit2gtk-4.1 + libgtk-3 from your distro (sudo apt install ./OwLLM.Desktop.deb).}

Your team of AI agents. Build them. Own them. Run them anywhere.

OwLLM is an open platform to build, deploy, and run custom AI agent teams — on your hardware, your VPS, or in a VM, 24/7. Bring your own models: local, cloud, or both. Fine-tune. Quantize. Abliterate. Red-team. Automate.

[!IMPORTANT] OwLLM Desktop ships for Windows 10/11 (x64) and Linux (x86_64) (AppImage + Debian/Ubuntu .deb). macOS (Apple Silicon + Intel) is next via the already-configured cross-platform CI. Watch the repo for release notifications.

What makes OwLLM different

Most AI tools give you a chatbox. OwLLM gives you a workforce.

You compose teams of specialised agents — an orchestrator that plans, a coder that writes, a critic that reviews, a researcher that fact-checks — and they collaborate on real tasks in parallel. Each team is a graph of roles + prompts you define. The 18 teams shipped in this repo are starter samples, not the menu.

flowchart LR
    G(["🎯 Your goal<br/>typed · Telegram · WhatsApp<br/>Slack · Discord · email"])
    G --> O["🧠 Orchestrator<br/>plans + right-sizes the round"]
    O -->|"@coder"| A1["👷 Coder<br/>edits in its own worktree"]
    O -->|"@researcher"| A2["🔎 Researcher<br/>web + citations"]
    O -->|"@critic"| A3["🧐 Critic<br/>reviews what a build can't catch"]
    A1 --> V{"✅ Verification Gate<br/>a REAL command's exit code<br/>never the model's say-so"}
    V -->|"fail — captured error"| A1
    V -->|"pass"| P["🚀 Publisher<br/>version → commit → tag →<br/>build → sign → release"]
    A2 --> O
    A3 --> O
    N["📓 Run Notebook<br/>your ideas while they work"] -.->|"⚡ steers mid-run"| O

    classDef goal fill:#0a2230,stroke:#3ec5d8,stroke-width:2px,color:#dff6ff;
    classDef agent fill:#1a1430,stroke:#8a7ad8,stroke-width:1.5px,color:#e8dfff;
    classDef gate fill:#2a2208,stroke:#ffcf5a,stroke-width:2px,color:#fff3d0;
    classDef ship fill:#0e2a1e,stroke:#3ec58a,stroke-width:2px,color:#d6ffe9;
    class G goal; class O,A1,A2,A3,N agent; class V gate; class P ship;

And you're never locked out while it runs: messages you type mid-run are injected into the working agents (on local models, between tool calls), and the Run Notebook lets you brainstorm next steps that auto-feed the team as each run finishes.

	What OwLLM gives you that others don't
🧩 Build your own teams	Compose agents from 8 base roles + custom prompts. Visual graph builder. Hot-updates through this repo — push a team JSON, it lands on every installed app.
☁️ Cloud OR local — same teams	No 4090? Plug in Claude / GPT / Gemini / Kimi keys, teams work identically. Have a GPU? Run open-weight models locally and stop paying per token. Mix both in the same conversation.
🎓 Fine-tune any model	Full LoRA + Unsloth + TRL pipeline. Drop a JSONL, watch loss curves, save adapters. Works on consumer GPUs (8 GB+).
🔬 Abliterate for safety research	Orthogonalise weights against refusal directions. Generate adversarial datasets. Train better safety classifiers. The honest tools the field actually needs.
🛠 GGUF + quantization built-in	Convert HF safetensors → GGUF, quantize Q4/Q5/Q6/Q8/F16. Ship custom models anyone with llama.cpp can run.
🛡 Red-team capable	Compose adversarial agent teams whose job is to find vulnerabilities — in models, code, apps. Pair with fine-tuning to train defenders.
🔒 Sealed to ONE folder (Win/Mac/Linux)	Flip it on and every tool your agents run — shell, file writes, edits, search, and the cloud CLIs (Claude/Codex/Gemini/Kimi) — runs inside a real Linux sandbox (WSL2 on Windows, Lima VM on macOS, bubblewrap on Linux (Mac/Linux beta)). Agents are sealed to ONLY the project folder: they work on your real Windows folder — no copy — but cannot see the rest of your C: drive, other projects, or your home / SSH keys. A model that runs `rm -rf` simply has nothing else to reach. Isolated by default; the seal and toolchain auto-install; provider logins (CLIs and API keys) auto-sync in so cloud agents just work. Connect GitHub to clone/push private repos from inside. See the 🔒 Sealed to one folder section below for the diagram.
🔌 MCP-first tooling	Plug in any Model Context Protocol server (filesystem, git, browser, Postgres, GitHub…). Keyless DuckDuckGo web search is auto-installed on first run — no API key, no card. Engine-agnostic: any search MCP you add is used automatically. Curated packs per team.
🏠 Run anywhere	Desktop today. Headless on a $5/mo VPS, 24/7 — on the roadmap. Containerised / VM — on the roadmap. Your agents, your hardware, your terms.

Built to work beside your editor — not imitate it

Keep VS Code, JetBrains, Neovim, or whatever editor you already love. OwLLM does not try to replace their IntelliSense, debugger, or extension ecosystem. It owns the larger workflow an editor was never designed to own:

Your editor handles	OwLLM handles
Editing, navigation, debugging	An agent workforce — orchestrator + specialists working in parallel, with each Code page isolated in its own Git worktree
One vendor's AI plan or an API key	The model you choose — local GGUF, cloud APIs, or subscription CLIs you already pay for: Claude Code, Codex, Gemini, and Kimi
Calling a model	Building the model — PDF/DOCX/URL → instruction JSONL → LoRA/QLoRA → GGUF export → quantization → local serving
An agent saying “done”	A real verification gate — the committed Project Card defines the command; only its exit code passes
Saving source files	Shipping the product — deterministic bump → commit → tag → build → sign → release → updater verification
A browser extension or test runner	A native agent browser — persistent signed-in sessions, localhost/live-site testing, form filling, mobile emulation, and an encrypted password vault
One local working tree	Cross-machine coordination — private worktrees plus a fetch/classify/three-way-merge/push coordinator that never force-pushes and preserves real conflicts
Your current computer	Your fleet — even below the OS — encrypted remote shells and agent commands across paired PCs; NanoKVM/PiKVM control reaches BIOS, boot menus, power, keyboard, and mouse
A prompt/rules file	Durable team memory — facts and worklog are retrieved with RAG and synced across your own PCs
A workstation install	OwLLM Go — portable mode redirects app state, models, configuration, and webview data to a USB drive

VS Code writes code. OwLLM runs the workforce that verifies it, ships it, and can operate the machines it runs on.

⚔️ OwLLM vs the field

Every tool below is good at its one thing. OwLLM's pitch is that the whole pipeline lives in one app — and the pieces compound: the team you built fine-tunes the model it runs on, inside a sandbox, reachable from your phone.

Capability	OwLLM	LM Studio	Ollama	Jan	AnythingLLM	Cursor
Local GGUF serving + model browser	✅	✅	✅	✅	⚠️ via others	❌
Agent teams (orchestrator + parallel specialists)	✅	❌	❌	❌	⚠️ basic	❌
Verified "done" (real exit-code gate, not model claims)	✅	❌	❌	❌	❌	⚠️
Fine-tuning (LoRA/QLoRA) built in	✅	❌	❌	❌	❌	❌
GGUF conversion + quantization built in	✅	❌	⚠️ import	❌	❌	❌
Abliteration / safety-research tooling	✅	❌	❌	❌	❌	❌
6 messaging bridges (Telegram · WhatsApp · Discord · Slack · Email · LINE)	✅	❌	❌	❌	❌	❌
Folder-sealed Linux sandbox for agent tools and cloud CLIs	✅	❌	❌	❌	❌	⚠️
Mid-run steering + Run Notebook (plan while they work)	✅	❌	❌	❌	❌	⚠️
Team memory: durable facts + RAG, synced across your PCs	✅	❌	❌	❌	⚠️	❌
Subscription CLIs as agents (Claude Code · Codex · Gemini · Kimi)	✅	❌	❌	❌	❌	❌
Rule-based release pipeline (agents that actually SHIP versions)	✅	❌	❌	❌	❌	❌
In-app support agent that sees your screen (the Watcher)	✅	❌	❌	❌	❌	❌
Fleet control — agents that drive your other machines (encrypted, LAN/WAN/P2P)	✅	❌	❌	❌	❌	❌
Cross-PC repo sync — real three-way merge coordinator, never a FF dead-end	✅	❌	❌	❌	❌	❌
Price	Free	Free	Free	Free	Free	$20+/mo

Fair notes: LM Studio is a superb model runner; Cursor is a superb code editor. OwLLM doesn't replace your editor — it replaces the five separate apps between "I have a GPU" and "my own trained, sandboxed, always-reachable agent workforce".

🔒 Sealed to one folder — nothing else

Give an AI agent a shell and it can read your SSH keys, wander into other repos, or rm -rf the wrong thing. OwLLM puts a hard wall around that. Turn isolation on (it's the default) and every command runs inside a Linux sandbox that can see only the project folder you're working on — your real Windows folder, mounted live with no copy — and nothing else of your machine.

flowchart LR
    A["🤖 Agent<br/>shell · edits · cloud CLIs<br/>(Claude · Codex · Gemini)"]
    A ==>|"sealed by bubblewrap inside WSL2"| BOX

    subgraph BOX["🔒 The sandbox sees ONLY this"]
        direction TB
        P["📁 Your project folder<br/>your real Windows files — no copy"]
        K["🔑 The agent's own logins<br/>auto-synced — cloud agents just work"]
    end

    BOX -.->|"🚫 blocked"| C1["🗂️ Rest of your C: drive"]
    BOX -.->|"🚫 blocked"| C2["📦 Your other projects"]
    BOX -.->|"🚫 blocked"| C3["🔐 Home · SSH keys · browser"]

    classDef safe fill:#0e2a1e,stroke:#3ec58a,stroke-width:2px,color:#d6ffe9;
    classDef block fill:#2a1414,stroke:#d86a6a,stroke-width:1px,color:#ffd9d9;
    classDef agent fill:#0a2230,stroke:#3ec5d8,stroke-width:2px,color:#dff6ff;
    class A agent;
    class P,K safe;
    class C1,C2,C3 block;
    style BOX fill:#0c1f17,stroke:#3ec58a,stroke-width:2px,color:#d6ffe9;

Real folder, no copy — work on C:\code\my-repo directly; changes are immediate, nothing is duplicated, no disk doubling.
Keeps working after you seal it — the agent's Claude/Codex/Gemini logins are bound in, so the team doesn't suddenly ask you to log in again.
One toggle, honest feedback — press 🔍 Verify and the app runs a probe through the agent's own shell and tells you plainly: runs in WSL? sealed to only this folder? — and installs the seal if it's missing.

💾 …and it cleans up after itself

The sandbox lives in WSL, whose virtual disk only ever grows. A Sandbox disk card on the Home page keeps it honest:

Action	What it does	Cost
See usage	WSL disk size + reclaimable caches (uv / npm / pip) + project-copy size, at a glance	—
🧹 Clear caches	Drops regenerable build caches — never your projects, logins, or models. Often frees many GB in seconds	instant, no restart
💿 Reclaim disk	Physically shrinks the WSL disk file and reports exactly how much came back	restarts WSL · admin prompt

Deleting a project also frees its sandbox copy automatically — your own folders are never touched.

What teams can do

OwLLM ships starter teams in nine categories. All of them are forkable and remixable — they're templates, not the menu. The real product is the team builder.

Category	What teams here do	Starter samples
🛠 Code	Architect → code → critic → refactor; bug hunting; reviews	`code_artisan`, `dev_squad`, `code_reviewer`, `bug_hunter`
🔬 Research	Multi-source synthesis with real citations, fact-checking	`research_lab`, `learning_tutor`
📊 Data	SQL → notebook → viz → narrative	`data_analyst`
🎨 Design	Product → UX → tech → critique	`product_studio`
✍️ Writing	Outline → draft → edit → SEO → publish	`writers_room`, `social_desk`
🤝 Ops	Triage → respond → schedule → digest	`secretary`, `concierge`, `customer_support`
💼 Personal	Calendar, finance, health, home automation	`finance`, `health_coach`, `smart_home`
🌐 Social	Outreach, support, community management	`sales_outreach`, `n8n_workflow_builder`
🛡 Safety / Red-team	Adversarial dataset generation, jailbreak research, refusal probing	(build your own — see data/teams/SCHEMA.md)
🎮 Gamify	Agent-vs-agent, achievements, arena	(in progress — Q4 2026)

Browse the 18 starter teams → · Build your own →

Build your own team — 5-minute walkthrough

Open Studio in the desktop app
Drop in agents: orchestrator + 1..N specialists (coder, critic, researcher, brainstormer, devops, documentation, operator, …)
Wire the dispatch graph (orchestrator → coder → critic → back to orchestrator)
Write each agent's system prompt
Save → team appears in your picker
Publish to the community via PR against data/teams/ — your team becomes one-click installable for every other user

Power tools nobody else ships

Fine-tune any open-weight model

LoRA pipeline with Unsloth, TRL, PEFT, bitsandbytes. Llama / Qwen / Mistral / Gemma — anything on HuggingFace. Live loss curves, graceful Stop preserves checkpoints, resume-from-checkpoint and resume-adapter both supported. Runs on a 12 GB GPU.

Abliterate (refusal removal for safety research)

Orthogonalise weight matrices against refusal directions — now with effect-based (causal) selection: it measures refusal on a held-out set, tests candidate directions by actually ablating and re-scoring, keeps the one that drops refusal most, and stops before over-ablating. You get a real before/after compliance number, and it works on strong RLHF models that defeat the classic single-direction recipe. Use cases:

AI safety labs training refusal classifiers need cleanly-uncensored teacher models
Red teams need models that don't sandbag jailbreak tests
Academic research on alignment failure modes

The corpus prep + abliteration script ship together.

GGUF creation + quantization

Convert HF safetensors → GGUF, quantize to Q4_K_M / Q5_K_M / Q6_K / Q8_0 / F16. The same pipeline that gives you tiny, fast custom models others can run on llama.cpp / Ollama / LM Studio.

Adversarial dataset generation

Build a team whose role is to PROBE another model. Output: a labelled dataset of jailbreak attempts, refusal patterns, edge cases. Sells to AI safety labs. Trains your own filters.

Cloud or local — same teams, your choice

You don't need a 4090. Many users will never have one.

Cloud-only: Plug in Claude / GPT / Gemini / Kimi API keys. Teams work identically. ~30 MB install, runs on any laptop.
Local + cloud mix: Have a 3060? Run Llama for the bulk, hand off to Claude for the hard parts in the same conversation. Save 90% on tokens.
Local-only: Have a 4090? Never touch a cloud API. Privacy by default. Stop paying per token forever.

Same teams. Same agent definitions. Same UI. The model layer is just plumbing.

Run anywhere — and places nothing else can go

Mode	Status	Use case
Desktop (Windows)	✅ shipped	Daily-driver AI workstation on your laptop
Desktop (Linux x86_64)	✅ shipped	AppImage + Debian/Ubuntu `.deb`
Desktop (macOS)	🔜 next	Apple Silicon + Intel via cross-platform CI
Fleet — your other machines	✅ shipped	Pair your PCs; agents run commands, open a remote shell, and drive them over an encrypted LAN / WAN / P2P channel.
Headless on VPS (24/7)	🔜 Q4 2026	Run your custom teams on a $5/mo box. Reach them via Telegram, web, API. Always-on agentic services.
Containerised / VM	🔜 Q4 2026	Drop OwLLM into your existing infra.
🔑 OwLLM Go (USB)	🧪 in design	Your entire AI workforce on a hardware key — see below.
🖥️ OwLLM Node (KVM)	🧪 prototyping	Teams that control other computers' physical screens — see below.

The team definitions, role prompts, MCP configs, and model selections are all portable across deployment modes — build a team once, run it anywhere.

flowchart TB
    T(("🦉 YOUR team<br/>roles · rules · memory<br/>built once"))
    T --> D["💻 Desktop<br/>daily driver"]
    T --> V["☁️ VPS 24/7<br/>answers Telegram/WhatsApp<br/>while you sleep"]
    T --> U["🔑 OwLLM Go<br/>USB key — any PC becomes<br/>YOUR workstation in 60s"]
    T --> K["🖥️ OwLLM Node<br/>KVM — hands + eyes on<br/>remote physical machines"]

    classDef hub fill:#0a2230,stroke:#3ec5d8,stroke-width:3px,color:#dff6ff;
    classDef mode fill:#0e2a1e,stroke:#3ec58a,stroke-width:1.5px,color:#d6ffe9;
    class T hub; class D,V,U,K mode;

🔑 OwLLM Go — your workforce in your pocket

A hardware key that carries the whole thing: the app, your models, your teams, your memory, your logins. Plug it into any computer — a hotel business center, a client's spare laptop, a fresh machine after yours died — and sixty seconds later your agents are running, with your knowledge, signed into your accounts. Pull the key and nothing stays behind. The device is the license, the backup, and the security boundary all at once. No install, no cloud account, no trace.

🖥️ OwLLM Node — agent teams with hands on real screens

A palm-sized KVM device (HDMI in, USB-HID out) that gives an agent team eyes and hands on any physical computer — below the OS, BIOS included, no software installed on the target. Now scale that thought:

Fleet support — an airport, a mall, a hotel lobby: dozens of screens nobody watches. A vision-capable team watches all of them, spots the frozen kiosk / crashed signage / stuck till, and fixes it — or files a ticket with a screenshot and what it already tried.
Remote hands for IT — "the server in the branch office won't boot" no longer means driving there. The team enters the BIOS, changes the boot order, reinstalls, reports back.
Legacy machines — the lab instrument PC from 2009 that can't have anything installed on it? A Node gives your agents control without touching its disk.
Grandma's PC — a Node on her desk means your concierge team is her tech support, with infinite patience, on demand.

🧭 More places this architecture goes

🔒 The air-gapped consultant — regulated site, no internet, no cloud? OwLLM is local-first by construction: models, fine-tuning, memory, teams — all offline on one workstation. Defense, medical, legal — the industries priced out of cloud AI are the ones OwLLM serves best.
🏭 The model foundry — fine-tune → abliterate (for safety research) → quantize → GGUF → publish. A one-person model lab, end to end, in one app. Your niche expert model, trained on your data, shippable to anyone with llama.cpp.
🎓 The intern that actually learns — your corrections don't evaporate: the Dataset Builder turns your documents and feedback into training JSONL, and this weekend's fine-tune is next week's smarter local agent. A workforce with a growth curve — try that with a SaaS chatbot.
📟 The personal firm — secretary, finance, research, health-coach teams, all reachable from the messenger already in your pocket. Not "an assistant app": a staff.

Install

Windows

Download OwLLM.Desktop.Setup.exe (~30 MB — one file, that's it)
Run it. The installer and the app binary are EV code-signed (Certum EV certificate). If SmartScreen still shows a prompt while the certificate's reputation builds, click "More info" → "Run anyway" — the publisher name confirms the signature.

Linux (x86_64) — AppImage (chmod +x and run, nothing to install) or .deb (sudo apt install ./OwLLM.Desktop.deb). Then: 3. On first launch, a hardware-aware wizard opens. It detects your hardware and offers the modules that fit:

Local Inference (~33 MB CPU / ~32 MB Vulkan / ~285 MB CUDA) — only needed if you want local models
Audio / Speech-to-Text (~148 MB) — for voice messages, mic input
Fine-tuning (~12 GB) — only if you'll train models
MCP toolchain (~260 MB) — only if you want browser / git / postgres MCP servers

Cloud-only? Skip the wizard entirely and just enter your API keys in Settings. The shell alone is enough for cloud-model chat + agent orchestration.

How updates work

Three independent update streams — small, fast, no full reinstalls:

Shell auto-updates via Tauri's signed updater
Modules (llama backend, fine-tune env, audio, MCP) check + swap per-launch
Data layer (team templates, role prompts, model profiles, MCP recommendations) hot-pulls from data/ in this repo on launch. A new team you contribute today reaches every installed app within minutes — no rebuild.

That's why the data/ tree is open and community-driven even though the app binaries are closed-source.

📐 How OwLLM's agents are built — design & the science behind it — evidence-based architecture (single-agent verify-loops for code, parallel teams for research), with diagrams and cited research.

✨ Recent highlights

OwLLM ships fast. Here's what landed across the 0.6.37 → 0.9.42 releases.

🛰️ Fleet Control — your agents reach your other machines (0.8.35 → 0.8.56)

Pair your computers and your agent teams can run commands on them, open an interactive SSH-like shell, and drive them — no SSH setup, no port-forwarding. Devices talk over an end-to-end-encrypted channel (Ed25519 + X25519 sealed envelope), reachable on your LAN, across the WAN (overlay / public / relay), or through a zero-setup embedded P2P transport (iroh) that punches through NAT for you. Same-account machines auto-enable and self-heal pairing; the first injection into a new host still asks for your per-host approval. Even subscription-CLI agents (Claude Code / Codex) can drive a paired device. This is the software half of "run your workforce anywhere" — and no other local-LLM app ships it.

🖥️ Agents with hands on real screens — the KVM tool is live (0.8.32)

The kvm_node tool (screenshot · type · keys · mouse · boot-key) is now wired into every agent path, so a team can control a networked KVM device below the OS — BIOS included — with nothing installed on the target. OwLLM Node moves from concept to a callable capability.

🔄 Cross-PC sync coordinator — no more merge dead-ends (0.9.26 → 0.9.42)

The same repo edited on two PCs used to hit a wall: Merge/Push were fast-forward-only and simply rejected divergence, even when Git could safely combine the two edits. Now Merge, Push, and Publish route through one coordinator transaction: fetch origin → classify (ahead / behind / diverged) → on divergence do a real three-way merge on a throwaway worktree → conflicts are preserved with both sides intact, never force-pushed → push with rebase-retry. And (0.9.42) agent runs now require isolated worktrees instead of silently falling back to the shared project folder — so parallel agents and parallel PCs stop clobbering each other's history.

🍎 Cross-platform: macOS signing + ARM64 / Jetson (0.8.43 → 0.9.11)

Real groundwork for the platforms beyond Windows: a code-signing certificate vault + management page, the ability to accept Apple's bare .cer and generate the signing CSR in-app (no Mac needed), Apple-Silicon runtime modules + whisper auto-install, a Jetson CUDA engine + ARM64 runtime modules with honest per-arch gating, and Linux aarch64 AppImage/deb/rpm built on-device. Releases are now signed across all platforms.

🌍 The OwLLM World Map (0.9.14 → 0.9.40)

A live, ambient view of the OwLLM fleet: a globe with real-clock lighting, satellite fleet orbits, live device loading, a private-fleet mode, and a Solar-System explorer. The first slice of the gamification track — presence you can actually watch.

🛒 Creator marketplace + guided onboarding (0.9.26 → 0.9.36)

Creator self-service, a marketplace surface in Settings, GitHub repo-picker import, and a guided onboarding / account-setup flow with a dedicated "Finish onboarding" step — the on-ramp for sharing and installing community teams.

🧷 History that survives updates — WebView isolation, fixed (0.8.96 → 0.9.5)

Updates used to migrate the WebView profile and appear to wipe your history. Now a SQLite mirror of durable localStorage restores projects, chats, notebooks, settings, model picks, and Code conversations across profile changes, orphaned Code tabs are rebuilt from surviving sessions, and missing vault clones are recovered on startup. Side-by-side builds are isolated so they stop freezing each other.

🛡️ Security: credential-transplant guard (0.9.40)

A startup account-ownership guard compares your local .owllm vault's origin owner to your signed-in GitHub login and quarantines foreign credentials on mismatch — closing a cross-account key-leak path. The installer ships no keys.

🗂️ Notebook → a Kanban plan (0.8.9 → 0.8.23)

The Run Notebook's plan became a Now / Next / Later Kanban board; the Digest agent proposes fewer, larger implementation chunks and persists its proposals; Start batch / Start queue make the plan runnable without consuming it; plus a media asset library and an issue tracker.

⚙️ More providers, more polish

xAI Grok Build CLI auto-installs on Windows (another subscription-CLI agent).
Concurrent local agents — llama.cpp auto parallel slots + continuous batching, so a local model serves several agents at once.
Images everywhere — render + click-to-zoom in every chat; CSV password import works around Chrome 127+ App-Bound Encryption.
Auto-resume interrupted model downloads via HTTP Range (no 0% restart).
Launch OwLLM at login (per-user, opt-out) · two-agent Code-page chat with two-way auto-feed · a dockable terminal above the composer.

🌐 The Agent Browser — native, shared, and on every model (0.7.53 → 0.7.78)

The browser your agents drive is now built into OwLLM — no Python, no bundled Chromium, no external window. It runs on the app's own engine (WebView2 / WebKit), opens instantly, and renders inside OwLLM's own dark chrome.

You and the agents share one window. Open a page, log in, and the team inherits the session. Ask “what's on this page?” and it snapshots, reads, clicks, and fills forms for you.
A dedicated Browser Agent — a team role that owns everything the sandbox can't: localhost dev-server previews, live sites, form testing. Its card is the browser remote (open URL, device, autofill, vault, import). Build a web app with the team, run its dev server, and watch the Browser Agent click through it.
Encrypted password vault + import — an on-device vault the agents autofill, with one-click import from Chrome, Edge, Brave, and Opera.
Mobile simulation + localhost — device presets (iPhone / Android / Tablet) with real viewports and mobile user-agents; localhost URLs just work.
Not Claude-only anymore. An in-app MCP gateway hands the same browser tools to agents on local models, Claude, OpenAI / Codex, and Kimi — on normal projects, and even to the Browser role inside a sealed sandbox.

🔌 Bring any model — 11 providers, one team (0.7.76 → 0.7.78)

Plug in a key or sign into a subscription CLI and the model joins your team:

	Providers
Subscription CLIs	Claude Code · Codex · Gemini · Kimi
API keys	Anthropic · OpenAI · Google Gemini · Kimi / Moonshot · DeepSeek · xAI Grok · Groq · Perplexity · Mistral · Together

Every one of them chats in a team. Full agentic tool-calling + browser control runs today on local models, Claude, OpenAI, and Kimi, with the rest rolling out. Provider logins — CLIs and API keys — auto-sync into the sandbox, so cloud agents keep working even when the project is sealed.

💻 Cross-platform + unified-memory ready (0.7.52)

Groundwork for Mac & Linux, and a real fix for modern hardware: the Metal (Apple) and Linux llama.cpp engines are packaged, and the GPU probe was rebuilt to understand unified memory — Apple Silicon, AMD APUs (Strix Halo / Ryzen AI Max), and NVIDIA Grace now report their real GPU-addressable budget, so model-fit colours and context sizing stop mis-judging shared-RAM machines.

🎨 Onboarding, redesigned (0.7.70)

The New Project dialog is now visual: pick a card for what you're making — Website / Web app, Mobile app, Software, Personal assistant, Bug fixing, Code review, Research, Writing… — and OwLLM pre-picks the right team, seeds a tailored brief, and sets up the sandbox. One click from “I want to build X” to a working team.

📝 Notebook & Code-page polish (0.7.47 → 0.7.68)

The Run Notebook now drafts a real plan (objective · approach · milestones) from your brainstorm — not just a step list — and its digest agent's model is a picker you control.
Two Code pages on the same project — run parallel work on separate branches and merge when ready.
The Code page's right column is now two resizable tabs (Super User rules · Notebook), plus a bottom utility bar: a mode switch (Plan / Auto / Chat), a floating terminal, and live account-usage meters.

📓 Plan while they work — mid-run steering + the Run Notebook (0.7.44 → 0.7.46)

The single most requested workflow fix: you are never locked out while agents run.

Mid-run steering that actually lands — messages typed during a run are queued as ⚡ steers and injected into the working agents: at the next agent boundary on cloud paths, and between tool calls on local models (the same trick VS Code uses). Never ignored, never lost.
The Run Notebook — a scratchpad popup that lives alongside the run: brainstorm freely, keep an ordered NEXT-STEPS list, and let the 🪄 Digest agent rewrite your raw notes into clear, self-contained steps (additive — it proposes, you approve). Feed a step to the running team with one click, or flip Auto-feed and the team walks your roadmap by itself, one step per clean finish.
Multiple Agents pages — a tab strip (like the Code page) opens several agent teams at once, same or different projects, running in parallel. Tabs stay alive; a green ● marks a page with a live run.
The Code page grew a ⚡ Super User column — the same project RULES the team follows (shared rule set when the folder is a team project) + the Notebook, wired into the solo coder with the same mid-run steering.

🧠 Team memory made real (0.7.37)

The shared brain got a ground-up rebuild: durable FACTS (curated, deduped, synced across your PCs) split from the worklog (auto-captured activity, local, capped), a BM25-lite ranker so a one-line fact beats 700 chars of chatter, a two-tab viewer with tag filters and 📌 promote-to-fact, and a 3D graph that clusters by topic instead of one giant hairball.

🌐 Browser Control + a signed, trustworthy binary (0.7.27 → 0.7.36)

Browser Control v1 — a persistent, logged-in browser the model drives: your sessions, your cookies, real sites.
EV code-signing everywhere — the app binary AND installer are signed with an EV certificate (0.7.33), building SmartScreen reputation under one identity.
Solo-Loop v2 — one canvas switch flips between full Orchestrated Workflow and a lean Coder → Critic → Publisher loop for quick fixes; same cards, same release controls.
Deterministic preflight — a goal that points at an unreadable out-of-project file stops in seconds with the exact fix, before any agent burns a token; readable ones are auto-copied in. (URLs pass straight through to the agents' web tools.)

📇 The Project Card — your project's rules in one committed file (0.7.0 → 0.7.3)

One file, .owllm/project.json, holds how this project is built: its goal, the verify command(s) that ground "done", and the release config. It's committed, so the rules travel with the repo — every machine, every teammate, every OS uses the same ones — with sensible defaults so existing projects keep working untouched.

⚡ Solo or 👥 Team — your call, in the canvas header. Solo runs one coder in a tight edit → verify → fix loop with no orchestration — right for a one-line change or a quick fix. Team is the full adaptive orchestration. Per-project, remembered.
Releases that actually finish — by rule, not by vibes. When a goal says "publish", the release runs deterministically on the host: bump the version (rolls at 100), commit, tag, build, sign, create the GitHub release, verify the updater. No more an agent claiming it shipped and then deferring the real push. The whole pipeline is driven by the card, so it works for any project.
The Steward — a teammate that keeps the card honest. Add it to a team and it reviews the Project Card against the real repo and flags incongruences before a run wastes a token: a publish goal with no release config, a verify command that can't run here, a version file that doesn't exist — and, hardest, a card that says the source is private while the remote is public. Detection is rule-based (27 unit tests), not the model guessing; it proposes the smallest fix for you to approve.
Grounded "done", from the card. The Verification Gate now reads its command straight from the card's verify section (with the same auto-detect + honest "unverified" fallback), so a fresh clone is grounded with zero setup.

🧪 Agentic teams, rebuilt on evidence (0.6.78 → 0.6.81)

After a deep, citation-backed review of how agentic systems actually succeed and fail (Agentless, mini-swe-agent, Anthropic's multi-agent research, MAST's failure taxonomy, the "self-correction needs an oracle" results), we rebuilt the team engine around one principle: an agent never grades its own work.

The Verification Gate — a first-class, unit-tested check that decides "done" from a real command's exit code, never from the model's say-so. It works out-of-the-box: with no setup it auto-detects a sensible check from your project (npm run build, cargo check, pytest, go build…); set or override it in project settings (or a one-line .owllm/verify.json, with optional per-lane frontend/backend commands). If it genuinely can't find one it reports "unverified" — honestly, never a false "passed".
Per-agent verify-fix loops — each coder now edits → runs the gate in its own workspace → on a real failure, takes the captured error and tries again (bounded; stops early once it stops making progress). The agent is "done" only when the check passes, and the shared team memory records the real verify outcome, not the agent's claim.
The OWLLM Team — one adaptive build team that right-sizes itself: a one-file fix uses a single coder; a cross-lane feature locks a shared API contract first, then builds front-end and back-end together in isolated git worktrees (worktrees stop the lanes clobbering files; the locked contract stops them disagreeing on the shape). Critic reviews what a build can't catch, Red Team tries to break it, Publisher ships the release. One team that scales up or down, replacing five fixed coding teams. (The full design — diagrams and citations — lives in docs/AGENTIC_DESIGN.md.)

🎯 Teams that deliver — and a way to prove it

Teams actually ship now — the orchestrator right-sizes each round, routes code work to a coder (never the read-only design leader), enforces strict front-end/back-end layer ownership, and a Definition-of-Done gate flags a "code task" that produced zero file changes instead of trusting the model's prose. Universal across every team, on every model path.
An objective eval harness — two layers you can run with node, no test framework: a deterministic control-flow judge that checks routing, task-classification, the critic verdict and the done-gate for every bundled team (it already caught and fixed 2 real bugs), and a live-run scorecard that records what each run did and grades it against per-team expectations — so you see which agent misbehaved, not just that something went wrong. Every run ends with a one-line Run Report (who ran · wrote files? · critic verdict · done?) with a PASS/FAIL.
The big delivery fix (0.6.68) — multi-line dispatch instructions (a numbered change list, steps, a code block) used to reach the specialist truncated to just the first line, so the team received a header with no actual task and shipped nothing. Now the whole instruction arrives intact, and the end-of-run report no longer claims a task is "done" when a coder was dispatched but wrote nothing.
Leaner, more flexible teams (0.6.69) — with that bug fixed, the prompt scaffolding piled on to force delivery was removed: the always-on operating contract is half the size and the orchestrator guide is much shorter, so the model spends its attention on your task, not on reciting rules. Delivery is now enforced by the run diagnostics instead of by browbeating the prompt.
Teams that stay in sync (0.6.71) — the shared team memory now auto-captures what each agent did and feeds the relevant slice to the next agent (retrieved by the task, not by recency), so a coder builds on what the backend just shipped instead of redoing it. It records the work, not opt-in notes.
Smarter & snappier — fixed a regression that demoted the agent system prompt to plain user text (models "acting dumb"), 20–30 s typing lag over remote, and tool results that falsely showed "Failed."

🧠 Agentic memory that actually persists

Per-agent memory — every specialist now remembers its own prior turns across dispatches and across runs. Model-agnostic (local, Claude, Codex, Gemini, Kimi).
Shared team memory (RAG) — a durable, project-wide knowledge base the whole team pools what it learns into. Works on every model path now — a recent-memory snapshot is injected into every agent's prompt, and any agent (cloud CLI or API, not just local) can write a fact with a [REMEMBER …] line. Syncs across your PCs.
3D knowledge graph — explore that memory as a rotatable force-directed graph: 🧠 Memory → 🌐 Graph.

📋 A team operating standard

Projects ship with a native best-practice rule set (fully editable) — enforced for every agent and the Critical Thinker.
A standing operating contract: a conflict-resolution priority order, a Definition of Done, and an agent handoff format.
Your rules sync across machines.

🎓 Skills, by role, out of the box

A curated set of skill packs auto-equipped by role — coder, critic, researcher, writer, orchestrator… Add, remove, or install more (Anthropic / community) per agent.
Skills you can see — that load on any model — each agent wears a ribbon of skill badges on its card (📊 pptx, 📕 pdf, 🔍 code-review, 🐞 debugging…), hover for names. The full library auto-installs on first run, and any agent — Claude, Codex, Gemini, or local — pulls a skill on demand by reading it from the project with its own file tool. Most agent apps hide capability in a config file and wire skill-loading to a single model path; OwLLM puts each agent’s toolkit on the card and lets every model use it.

⚡ Local-model performance

VRAM-aware context — the context window is sized to fit your GPU after the model weights, so a big model stops silently spilling onto the CPU. Real, measurable speed-ups.
Direct-drive file tools — agents read your project folder straight off the disk instead of a slow WSL round-trip.

⏱️ Visibility & reliability

Run timers — a team stopwatch in the canvas header, plus per-agent working-time on every card.
No more idle CPU burn / freeze — the Agents views' animations now run only while agents are working and the window is visible, instead of re-rendering forever (which used to peg a core and leak memory until the app locked up).
No more orchestrator "crash after a few seconds" — a large agent system prompt (role + team + memory) was passed as one giant command-line argument and overflowed Windows' ~32 KB limit; large prompts now go through stdin instead, across every CLI provider.
Team agents honor auto-approve — with auto-approve on, dispatched specialists actually get write/exec permission (was gated regardless of the toggle); image paste/drop no longer fails with "Access is denied."
Hardened the subscription path (transient 401 / 529 auto-retry), the WSL sandbox credentials + folder handling, and post-reboot cold-start hangs.

💬 Chat & UI polish

Server page tells you what's live — Select Model pre-selects the running model, and the context window in effect shows as a live ● Live: N tokens badge (read from llama-server) so you never guess what's loaded.
Cleaner team diagram — ring distances are fixed per layer instead of stretched to fill the canvas; a single-layer team no longer flings its ring out to the outer-layer distance.
Ctrl+A behaves — select-all inside a chat now grabs only that conversation, not the whole app window. Clean copies again.
Live tok/s in the header — your local generation speed sits next to the API key and updates even through thinking- and tool-heavy turns.
No more doubled output — fixed a race that could run a team's orchestrator twice at once, interleaving two streams into one garbled reply.

Full changelog (0.6.37 → 0.9.42)

Version	Highlight
0.9.42	Agent runs require isolated worktrees (no silent shared-folder fallback) · honor inherited agent model settings
0.9.40	Account-ownership guard quarantines transplanted `.owllm` credentials · `/dl` resolves per-OS to the newest build · World Map Solar-System explorer
0.9.39	macOS auto-updates fixed — signed app bundle preserved after launch
0.9.36	Notebook working-notes auto-clear · dedicated "Finish onboarding" settings row
0.9.32	World-Map persistence client · fixed additive presence counts (stable-id clients only)
0.9.29	Onboarding account setup · GitHub repo-picker import · notebook window-lease + cross-PC sync
0.9.27	Signing popup · real-clock globe lighting · marketplace in Settings
0.9.26	Cross-PC sync coordinator — one transaction replaces FF-only Merge/Push dead-ends · creator self-service · guided onboarding
0.9.14	World Map + private-fleet modes
0.9.5	Recover missing vault clones on startup
0.9.3	Recover projects, settings, notebooks, model picks & Code chats across WebView profile changes
0.9.2	SQLite mirror of durable localStorage — history survives WebView profile changes · Tao keyboard-deadlock patch
0.8.99	Reliable Linux device login · recover chats after updater profile migration
0.8.96	Fix app-wide WebView freezes · isolate side-by-side builds
0.8.87	Linux aarch64 GUI frame fix · AppImage auto-update (Jetson unified VRAM in header)
0.8.86	Per-install update path — deb/rpm gets Download, not a failing Install
0.8.80	Prevent WSL disk inflation safely — auto-trim + sparse opt-in
0.8.58	Launch OwLLM at login (per-user, opt-out) · stop the model server before applying an update
0.8.54	xAI Grok Build CLI auto-installs on Windows
0.8.53	Remote Devices — auto-enable inbound listener for same-account machines
0.8.50	Images everywhere + click-to-zoom · CSV password import (Chrome 127+ App-Bound Encryption) · size local context from real GGUF KV geometry
0.8.49	Embedded P2P device transport (iroh) — zero-setup off-LAN control · current-device ground truth in every prompt
0.8.48	Event-loop-free Win32 geometry sync — stop the overlay UI-thread deadlock
0.8.47	Credential hub — live readiness probes, in-app portals, web logins · agent browser gets the OwLLM chrome bar
0.8.43	Signed releases across all platforms — code-signing cert vault · Apple `.cer`+CSR in-app · Jetson CUDA + ARM64 modules · resume interrupted downloads
0.8.40	Remote-devices pairing fix — real endpoints published at launch, self-healing Pair
0.8.39	Subscription-CLI agents (Claude Code / Codex) can drive paired devices
0.8.38	Interactive remote shell (SSH-like) + agent access to paired devices
0.8.36	Remote-devices WAN control — overlay / public / relay, not LAN-only
0.8.35	Remote Devices / Fleet Control — LAN-direct transport, discovery, approved-dangerous ops · Linux `/dl` links + stable-named assets
0.8.34	Rule-based publish works for any repo · create the GitHub repo for the user in onboarding
0.8.33	Two-agent Code-page chat — selectable last-reply auto-feed both ways
0.8.32	Expose `kvm_node` to every agent path · settable publish target repo · notebook LogBox + adaptive Kanban
0.8.23	Notebook plan becomes a Now / Next / Later Kanban board
0.8.22	Notebook redesign — one working-notes box, Digest reads notes/plan/steps
0.8.15	Memory Curator context packs — retrieved memory is reference-only, current-task dominated
0.8.10	Code-page publish cards in the file-tree rail (commit / merge / push / publish, rule-based)
0.8.9	Notebook redesign · media asset library · issue tracker
0.8.6	llama.cpp auto parallel slots + continuous batching for concurrent local agents
0.8.1	Kimi balance + meaningful usage notes for all providers
0.7.92	Production smoke matrix — the ship/no-ship gate
0.7.88	Fix Claude on the Code page ("command line too long", `.cmd` shim ~8 KB) · `--prerelease` publish channel
0.7.79	Auto-`/login` on Connect for REPL CLIs · Kimi K2.7 in the catalogue
0.7.78	Kimi CLI works inside the WSL sandbox — installed in the seal, login detected, real disconnect
0.7.77	Browser gateway reaches Gemini & Kimi CLI agents · Kimi subscription detected after login
0.7.76	OpenAI API-key agents get the full tool loop — browser + files, model-agnostic
0.7.74	Non-Claude CLIs call `mcp__owllm__browser_*` directly (no ToolSearch) — fixes “0 browser tools”
0.7.72	Codex / OpenAI CLI agents reach the in-app browser gateway
0.7.70	Visual New-Project onboarding — pick what you're building, get the right team + sandbox
0.7.69	The Browser Agent runs host-side even inside a sealed team (its sandbox exception)
0.7.66	The Browser Agent — a team role that owns localhost & the web; its card is the browser remote
0.7.62	Fix: a space in the config path silently starved CLI browser tools (short-path)
0.7.60	CLI agents get the browser under the correct `mcp__owllm__` tool names
0.7.58	Solo-loop graph fixed — Coder + Critic share a row, Publisher below; positions remembered per mode
0.7.53	Native Agent Browser — the app's own engine (no Python/Chromium) · password vault + import (Chrome/Edge/Brave/Opera) · mobile emulation · localhost
0.7.52	Cross-platform + unified-memory readiness — Metal/Linux engines packaged; Apple/AMD/NVIDIA shared-RAM budgets
0.7.49	Model-agnostic account-usage meters (every provider)
0.7.48	Code-page right column — project rules + Run Notebook, wired into the solo coder
0.7.46	URL-in-goal preflight fix (websites are fetched, never mistaken for files) · Notebook shows the digest agent's model
0.7.45	Mid-run steering that actually lands (injected between tool calls on local models) + the 📓 Run Notebook with Digest agent + auto-feed
0.7.44	Multiple Agents pages — tab strip, parallel teams on same/different projects, runs survive tab switches
0.7.37	Team Memory rebuilt — FACTS vs worklog split, vault quarantine, BM25-lite retrieval, redesigned viewer + graph
0.7.36	Solo-Loop v2 — canvas-title switch, lean Coder → Critic → Publisher loop, code-signing config on the Publisher card
0.7.33	EV code-signing for the app binary AND installer (one identity, SmartScreen reputation)
0.7.32	Catch-up Latest — Browser Control v1 (persistent logged-in browser the model drives) + out-of-project file auto-ingest
0.7.25–.26	Deterministic preflight — unreadable out-of-project brief stops the run in seconds with the exact fix; readable files auto-copied in
0.7.23	Agent editor ✨ Organize — split a freeform prompt into Mission / Rules / Definition of Done
0.7.13	Editable file viewer + verifiable skill sync
0.7.4	📇 Project Card editor in ⚙ Project settings — goal, verify, release config, Steward lint inline
0.6.87	Cross-provider skill self-load — agents on Claude/Codex/Gemini/local pull any skill by reading `.owllm/skills/<id>` with their native file tool
0.6.86	Auto-install the full skill library on first run (background, idempotent) — no manual Skill Library dialog
0.6.85	Skill badges — every agent card shows a ribbon of its equipped-skill icons (hover for names); capability is finally visible, not hidden in config
0.6.84	Fixed: TS-only builds shipped stale UI (now forced fresh embed) · team choice persists across restart · “shipped” ≠ committed honesty rule
0.6.83	Inline agent-card editor — click a card to edit that agent’s model, colour, and prompt (shipped in 0.6.84)
0.6.82	Verification gate works out-of-the-box — auto-detects a check (npm/cargo/pytest/go) + a Verify-command field in project settings
0.6.81	OWLLM Team — one adaptive build team (right-size activation + contract-lock before cross-lane fan-out) replacing five fixed coding teams · "Save as new…" team fork
0.6.80	Per-agent verify-fix loop — each coder edits→verifies→fixes against the real check; "done" is a passing build, not a self-report
0.6.79	The Verification Gate — a first-class, unit-tested check that decides "done" from a real exit code (`.owllm/verify.json`); honest "unverified" when none configured
0.6.78	Ground the loop in execution — real verify gate + bias-to-action + no self-conditioning (evidence-driven redesign)
0.6.77	Protect Code-page worktrees from the team sweep (no unmerged-work loss) + separate branch namespaces
0.6.76	Stop fleet worktrees piling up — no worktree for sequential runs + sweep crashed-run orphans
0.6.75	"Reset team to template" — pull template fixes (e.g. the publisher rename) onto an existing project's frozen roster
0.6.74	Publisher agent named as such; Info page cards flow at natural heights
0.6.73	The team ships its own releases — a Publisher role + host-side build/sign/publish/verify pipeline
0.6.72	Team-memory graph renders — visible connection lines + always-on node labels
0.6.71	Team memory becomes work-state sync — agents auto-record what they did and read teammates' relevant work; image-save (9P) fix
0.6.70	Studio agents — built-in roles in their own column, custom agents deduped by name
0.6.69	Restore the lean, flexible orchestrator — slim the prompt scaffolding that was compensating for the (now-fixed) dispatch bug
0.6.68	Fix teams unable to deliver — multi-line dispatch instructions were truncated to a header; honest "not done" report
0.6.67	Objective eval harness for teams — control-flow tests (all teams) + live-run scorecard + in-app Run Report
0.6.66	A routing test that judges every team — found & fixed 2 task-classification bugs
0.6.65	Harness-level run control — structured critic verdict · done-gate · oscillation break · routing parity
0.6.64	Deterministic routing in the harness — code tasks reach a coder, never the design leader
0.6.63	Tool results stop falsely showing "Failed" (use the real error flag, not word-matching)
0.6.62	Fix "smart model acting dumb" (system prompt was demoted to user text) + 20–30 s typing lag
0.6.61	"Stay in your lane" — layer ownership made universal across every team
0.6.60	Orchestrator right-sizes the round + strict front-end/back-end ownership
0.6.59	Product Studio fast-path — fix/ship an existing app without the design phase
0.6.58	Teams DELIVER — action-forcing orchestrator + operating contract
0.6.57	Land the team's in-repo work (dedupe agents, image-save diagnostics, WSL inbox retry)
0.6.56	Finish the orchestrator-crash fix for the Codex agent path (all CLI paths overflow-safe)
0.6.55	Fix orchestrator "crash after a few seconds" — system prompt overflowed the command line (os 206)
0.6.54	Team agents honor the auto-approve toggle (can write) · fix image-paste "Access is denied"
0.6.53	Team memory on every model path ([REMEMBER] writes + injected snapshot) · fixed runaway-CPU freeze
0.6.52	Server page shows the running model + live context · fixed diagram ring distances
0.6.51	Scoped Ctrl+A in chats · live tok/s in the header · no doubled orchestrator
0.6.50	Effect-based abliteration — causal selection + refusal benchmark
0.6.49	Context capped to fit VRAM (stops CPU spill)
0.6.48	Auto-context sized from free VRAM after the model weights
0.6.47	Time-bounded WSL warm-up — no post-reboot hang
0.6.46	Direct-drive file tools + run timers + 529 retry
0.6.45	WSL pre-flight folder-reachability check
0.6.44	Agents told their project root explicitly
0.6.43	3D memory graph + sandbox-credential 401 fix
0.6.42	Curated skill packs, auto-equipped by role
0.6.41	Project rules sync across PCs
0.6.40	Full Agent Team Rules + operating contract
0.6.39	Native best-practice rule set
0.6.38	Team-memory viewer + cross-PC sync
0.6.37	Per-agent memory + shared RAG team memory

Roadmap

Track active work in Discussions → Roadmap.

Who's this for

Indie devs & founders — your AI workforce, not a SaaS subscription
AI safety researchers — abliteration, red-team teams, adversarial dataset gen
Model creators — fine-tune, quantize, ship GGUFs
Automation builders — replace n8n / Zapier with agents that understand meaning
Privacy-bound teams — legal, medical, defence, regulated industries
Agencies — run custom client agent teams 24/7 (when VPS mode lands)
Power users — anyone tired of generic chatboxes

Community

💬 GitHub Discussions — Q&A, show what you built, roadmap input
🐛 Issues — bug reports (use the template)
🎨 Contributing — agent teams, roles, translations, docs

License

OWLLM, this repository's first-party contents, and the application binaries are proprietary software owned by Far island Corporation Ltd. Official unmodified executables may be used free of charge; no right is granted to copy, modify, redistribute, sublicense, or sell repository contents or binaries.

See LICENSE and the application EULA for the complete terms. Source for the application itself is not public.

Acknowledgements

Standing on the shoulders of: llama.cpp, whisper.cpp, Tauri, Unsloth, Model Context Protocol, and the open-weight model creators (Meta, Alibaba, Mistral, Google, DeepSeek, Anthropic for their safety research).

If you build something cool with OwLLM, share it in Discussions → Show & Tell. Stars are how this category proves itself worth investing in.

Name		Name	Last commit message	Last commit date
Latest commit History 58 Commits
.github		.github
assets		assets
data		data
docs		docs
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
EULA.md		EULA.md
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md

Uh oh!

Folders and files

Latest commit

History

Repository files navigation