TigrimOSR v0.6.2

TigrimOSR is a native desktop AI agent platform for orchestrating teams of specialist AI agents from a single self-contained binary — and for building your own agentic loop. Define swarms in YAML, wire them with inter-agent protocols (TCP, Bus, Queue, Blackboard), and let them collaborate autonomously. Then shape how the loop itself runs: pick the tools, MCP servers, and skills each agent may use, override its model and system prompt, tune self-verification and context compaction — all in simple YAML profiles you can edit from the desktop app or any browser. When the job is done, TigrimOSR doesn't take the agent's word for it: an independent tool-using judge verifies the deliverables actually exist before the answer reaches you. And you don't have to be at your desk for any of it — chat with your agent and drive it with slash commands straight from Telegram or LINE.

Why TigrimOSR?

• Multi-agent orchestration — 6 modes (hierarchical, mesh, hybrid, pipeline, P2P, P2P orchestrator) with real protocols and a shared blackboard.
• Your agent loop, your rules — customize the whole agent loop as YAML profiles: which tools it may call, which MCP servers and skills it sees, model & system-prompt overrides, loop limits, self-verification, and context compaction — editable from the desktop app and the web UI.
• Don't trust — verify (job evaluation) — LLM agents love to declare success: "Done!" with a missing file, a half-finished swarm job, a confident summary backed by nothing. TigrimOSR closes that trust gap: after the whole job finishes, an independent tool-using judge (optionally a different model, so the agent never grades its own work) checks the result against your objective and rubric — opening the output files to confirm the claimed artifacts actually exist — and feeds any gaps back so the orchestrator delegates targeted fixes before the answer reaches you. One verification per job, not per agent, so even big swarms stay fast.
• Any LLM, any provider — OpenAI, Anthropic, DeepSeek, Kimi, Gemini, Ollama, or any OpenAI-compatible API — plus 3 local CLI agents (Claude Code, Gemini CLI, Codex) with no API keys.
• Full tool calling — web search, Python, file I/O, shell, MCP servers, and the ClawHub skill marketplace. Charts, images, and docs render inline with click-to-zoom.
• Browser control — let the agent drive a real browser to search Google and read the live web directly. Choose your engine: Chrome / Chromium via Playwright, or the stealthy, Node-free Obscura engine (a single Rust binary with built-in anti-detection). It's a real browser, not a paid search-API — no API keys, free of charge, saves money. Opt-in toggle, off by default for safety.
• Plugin system — zip plugins bundling skills, MCP servers, agents, and connectors. Compatible with Claude Desktop/Code plugins and npm MCP packages.
• Run it your way — as a native Rust desktop UI on your machine, headless on a machine or in Docker, and connect from any browser via the built-in web UI. Toggle Local/Remote from one interface.
• Telegram & LINE bots — chat with your agent from the messaging apps you already use, and control it with slash commands (/agents, /model, /mode, /loop, /new, /stop, /status): live progress while it works, approve/deny buttons for tool approvals, and fail-closed user allow-lists. Telegram needs no public URL at all — see Telegram & LINE Bots.
• Private remote access (VPN) — reach a remote host over your own Tailscale VPN instead of exposing it publicly — devices talk over private 100.x addresses, nothing is published to the internet. Opt-in toggle, an alternative to the public Cloudflare tunnel.
• Built in Rust — fast, low-memory, single binary, no Node/Python runtime. Rewritten from TigrimOS (TypeScript/Python). Because both the app and the Obscura browser engine are native Rust, the whole thing — desktop UI, embedded server, and a live embedded browser — idles at only ~270 MB RAM (≈210 MB app + ≈60 MB browser), a fraction of what a Chromium/Electron stack needs just to open a tab.

Native Rust desktop app

Install it on your machine and run the UI as a native Rust app — a single, fast binary with quick startup and low memory.

Above: the native desktop app — ask for a plot and the agent runs Python (matplotlib) and embeds the chart inline in its answer.

Memory footprint

Because TigrimOS is native Rust end-to-end — the app and its Obscura browser engine — the whole stack stays remarkably light. On an idle desktop session with browser control on and a live browser attached, measured resident memory is:

TigrimOS (app + embedded server)   ≈ 210 MB
obscura (Rust browser engine)      ≈  60 MB
────────────────────────────────────────────
Total, with a live browser         ≈ 270 MB

That's roughly where a Chromium browser process alone tends to start. The reason is structural: most agent stacks pay for two heavy layers TigrimOS doesn't — an interpreted runtime (Node.js/Python) plus a multi-process Chromium driven by Playwright. TigrimOS replaces both with a single Rust binary and a single-process Rust browser.

For rough context, here's how that compares to two popular open-source browser agents. Only the TigrimOS figure is our own measurement; the others are third-party/community-reported and vary widely with workload — treat them as ballpark, not benchmarks:

Stack	Runtime + browser	Agent with a live browser
TigrimOS	Native Rust + Rust Obscura engine	≈ 270 MB (measured)
Hermes	Node/Python + Chromium (Playwright)	~1.2–1.8 GB (reported)
OpenClaw	Node.js + Chromium (Playwright)	2–4 GB typical; 7.5 GB+ multi-agent (reported)

A single Chromium instance commonly uses 800 MB–2.5 GB depending on the page, and per-agent-browser setups multiply that. Chromium/Playwright stacks also have to actively manage renderer-process accumulation and orphaned browsers across restarts (e.g. OpenClaw #29685) — failure modes TigrimOS avoids with per-session process groups and per-agent browsers that shut down with the session.

Not fixed: ~270 MB is the idle baseline with a browser attached. Real usage grows as Obscura renders heavy pages (its V8 heap climbs per page/tab) and as the app holds conversation, session, and swarm state — expect more under load, but still far below a Chromium-based stack.

Mobile Remote Connection

Run TigrimOS anywhere — as a native desktop app, headless on a machine, or in Docker — then connect from any browser or your phone. The screenshots below show a cloud server controlled entirely from a mobile browser: full chat with inline charts, tool execution, and file browsing.

  

Features

• Multi-agent system — hierarchical, mesh, hybrid, pipeline, P2P, and P2P orchestrator modes via YAML config
• Agent loop profiles — user-defined YAML profiles controlling the agent loop: tool allowlist/denylist, MCP server & skill selection, model/system-prompt override, loop knobs (rounds, temperature, reflection, step verification), job evaluation (outer loop, tool-using judge) and context compaction — see Agent Loop Profiles
• Local CLI agents — Use Claude Code, Gemini CLI, or OpenAI Codex as agent backends without API keys
• Plugin system — Zip-based plugins with skills, MCP servers, agents, and connectors. Accepts TigrimOS, Claude Desktop, Claude Code, and npm MCP formats
• Tool calling — web search, Python execution, file read/write, shell commands, skill loading, MCP tools
• Browser control — opt-in toggle that lets the agent drive a real Chromium/Chrome browser (navigate, click, type, screenshot, tabs, JS) via Playwright MCP, or the stealthy Obscura engine (single Rust binary, no Node required) — see Browser Control
• Remote access — Headless mode + embedded web UI for controlling from any browser or mobile phone
• Telegram & LINE bots — chat with the agent from Telegram or LINE and control it with slash commands (/agents, /model, /mode, /loop, /new, /stop, /status), with live progress and approve/deny buttons for tool approvals — see Telegram & LINE Bots
• Remote server dashboard — Connect your Mac app to remote TigrimOS instances
• Private VPN access (Tailscale) — reach a remote host over your own tailnet instead of a public tunnel — see Remote access over a private VPN
• VM integration — Built-in Ubuntu VM with SSH terminal and tool routing
• Customizable themes — color presets (Default, Dark, Minimal, Transparent, Colorful), full per-color editing, font selection (Inter, Geist, Roboto, IBM Plex Sans, Plus Jakarta Sans, or your own) and per-style sizes — all saved to data/theme.yaml
• Output panel or inline files — render images (PNG/JPG), markdown, CSV tables, JSON, PDF, HTML either in a side panel or embedded inline in chat with click-to-zoom (default)
• Agent history log — JSONL logs per session in data/agent_history/
• Skills system — loadable skill modules from skills/ directory
• Sandboxed Python — matplotlib plots auto-saved as PNG via Agg backend
• Resizable layout — drag handles for chat sidebar and output panel widths
• Session management — persistent chat history with project context
• LaTeX math — KaTeX rendering in web UI for equations and formulas

---

Installation

Two ways to install TigrimOS — pick one:

	Install in Docker	Install & run on your machine
What you get	Headless web server you use from a browser	Native desktop app (and optional headless server)
You install	Just Docker Desktop	Rust toolchain + Python (build from source)
Best for	Quickest, safest start; servers; Windows	Mac/Linux desktop UI, VM/QEMU terminal, hacking on the code
Setup time	One command	~5–15 min first build

Not sure? Use Docker — it's the fastest and safest, and the agent's code execution stays isolated inside the container.

---

Install in Docker (recommended)

Run TigrimOS as a self-contained web server in a container — no Rust toolchain, Python, or system libraries to install on your machine. You use it from your browser, and all agent code execution stays sandboxed inside the container, isolated from your host.

Prerequisites

• Docker with the Compose plugin (Docker Desktop on macOS/Windows already includes it). Verify with: bash docker --version && docker compose version

Three ways to start, fastest first:

• macOS — one command → run the docker-start.sh script (auto-token, builds, opens the browser).
• macOS / Linux — manual → the four steps below.
• Windows → Headless on Windows.

All three build the same container and share the same data, commands, and security model documented further down.

Easiest: one command (macOS)

If you just want it running, this single script checks Docker, auto-generates your login token, builds the container, starts the server, and opens the browser for you — no manual .env editing:

curl -sSL https://raw.githubusercontent.com/Sompote/TigrimOSR/main/docker-start.sh | bash

Want Browser Control too? Add INSTALL_BROWSER=true (bakes the browser into the image, ~400 MB):

curl -sSL https://raw.githubusercontent.com/Sompote/TigrimOSR/main/docker-start.sh | INSTALL_BROWSER=true bash

Already cloned the repo? Run it in place instead:

./docker-start.sh                      # or: INSTALL_BROWSER=true ./docker-start.sh

It prints your token (also saved to .env) at the end — paste it into the web UI to log in. Re-running is safe: it reuses your existing token. Prefer to do it by hand? Follow the four steps below.

Manual setup (macOS / Linux)

1. Get the code

git clone https://github.com/Sompote/TigrimOSR.git
cd TigrimOSR

2. Create your login token. Copy the example env file and put a strong random token in it. This token is what you'll type into the web UI to log in.

cp .env.example .env

# Generate a token and write it into .env:
echo "ACCESS_TOKEN=$(openssl rand -hex 32)" > .env

Keep .env private — it holds your login secret. It is already git-ignored. (On Windows, see Headless on Windows for the PowerShell equivalent.)

3. Build and start. The first build compiles the Rust binary and takes a few minutes; later starts are instant.

docker compose up -d --build

4. Open the app. Go to http://localhost:3001/web/ in your browser and log in with the token from your .env. Then set your AI provider and API key under Settings (saved to ./data, so it