SouravBeraAkaSpeed/xiryn

The open-source personal agent. It does everything Muse, Grok Bot and Dots do — on your own computer.
Each agent gets its own Linux desktop in Docker, so it works in the background and never interrupts what you're doing on your laptop.
Your data stays on your disk. Bring any model. Control it from anywhere through Telegram.

xiryn.com · Quick start · Why Xiryn · Compare · Telegram · Architecture · Contribute

This year every major lab shipped a personal agent that works on a cloud machine for you — Muse from Meta, Grok Bot from xAI, Dots from OpenAI. They're impressive. They're also closed, gated behind subscriptions, and they run on someone else's servers with your conversations, your logins and — when they shop for you — your payment details.

Xiryn is the same idea as an open-source personal agent you run yourself. Clone it, add your API keys, and you have a team of agents that each own a Linux desktop in Docker — working in the background while you keep using your laptop — remember what matters, browse and research the web, write and run code, and hand work to one another. Nothing is stored anywhere but your computer, and you can message them from your phone.

One command sets everything up — Git, Node.js, Docker, the agents' desktop — and starts Xiryn:

# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/SouravBeraAkaSpeed/xiryn/main/setup.sh | bash

# Windows (PowerShell)
irm https://raw.githubusercontent.com/SouravBeraAkaSpeed/xiryn/main/setup.ps1 | iex

No API key? Run it free. Add --local and the same command also installs Ollama, downloads a model that fits your computer's memory and makes it every agent's default — nothing leaves your machine, nothing is billed:

curl -fsSL https://raw.githubusercontent.com/SouravBeraAkaSpeed/xiryn/main/setup.sh | bash -s -- --local

$env:XIRYN_LOCAL="1"; irm https://raw.githubusercontent.com/SouravBeraAkaSpeed/xiryn/main/setup.ps1 | iex

Have a coding agent? Paste one prompt into Claude Code, Codex or Cursor — it installs everything, asks you for your keys and starts Xiryn.

🔒 Private by design. No account, no sign-up. Conversations, memory, settings and keys live in a single SQLite file on your disk; logins and cards, if you choose to save them, live in an encrypted vault whose key your operating system holds — and agents never see them. Even the agents' machines run on your computer. The only things that leave it are the calls you configure (your model provider, plus Firecrawl or Telegram if you turn them on). Run a local model through Ollama and not even your prompts leave.

🖥️ It never touches your computer. Every agent works on its own sandboxed Linux desktop — a Docker container with a shell, files and a real Chromium — completely separate from your system. It doesn't move your mouse, take over your screen or read your files. Watch a movie, play a game or keep coding while it works. Or watch it work, live, and take the wheel whenever you want.

📱 Control it from anywhere. Pair Telegram in two minutes — scan a QR code and you're done. No public URL, no tunnel, no port forwarding: Xiryn polls Telegram from your machine. Your agents answer from wherever you are, with live progress and screenshots.

🧠 Any model, your keys. OpenAI, Anthropic, Google, xAI, Groq, Mistral, DeepSeek, OpenRouter, Ollama, LM Studio, or any OpenAI-compatible endpoint. Pick a model per agent. No subscription — you pay providers directly for what you use.

🗑️ Disposable machines. Reset an agent and its container is destroyed. Delete it and it's gone. Turn on auto-delete and workstations vanish after every session — while the agent's memory stays safe on your disk.

👥 Agents that work as a team. Put several agents in a squad. Ask any of them; they delegate to whoever fits the job — each on its own model and its own machine.

_{Based on public launch coverage as of October 2026. These products move fast — corrections welcome.}

Anything that can be done with a terminal, a browser and a desktop — while you get on with your day:

• Build and debug — clone a repo, install, run the tests, fix what fails, show you the diff.
• Research — search, read primary sources, and come back with a cited summary.
• Write — launch posts, docs, reports, saved as files on its workstation.
• Work the web — fill forms, compare options, prepare a booking or an order. When a site needs your login, a payment or a CAPTCHA, the agent stops and hands you the screen; your card never touches Xiryn.
• Run as a team — ask a squad, and the right specialist takes it.

Agents ask when they need a decision, confirm before anything irreversible, and remember what you tell them.

• Take over — one click pauses the agent and gives you its desktop. Type, click, fix what it got wrong. Hand back with an optional note ("I picked the 6:40 flight") and the agent looks at the screen and continues from there.
• Hand-offs — at a login, a payment page, a one-time code or a CAPTCHA, the agent stops by itself and tells you exactly where it is and what's left. The take-over view opens on your screen, and if Telegram is paired you get a message with a live link to the desktop that works from your phone. Pay on the agent's screen, reply "done", and it wraps up.
• Browses like a person — agents open a site's home page and use its own search forms and filters instead of guessing deep links, so you can follow along and step in at any point.

• An encrypted vault for logins, cards, UPI IDs and personal details. Add them in Settings → Vault, or when an agent asks, through a secure form in the chat. They're encrypted with AES-256-GCM, and the key is held by your operating system (macOS Keychain, Windows DPAPI, the Linux Secret Service) — never next to the data.
• Agents never see the values. An agent gets "Visa ···· 4242"; Xiryn types the card into the page itself and shows the field as dots.
• Every payment needs your yes. At checkout the agent asks — "Atlas wants to pay ₹19,062 to MakeMyTrip" — and you choose Approve (it pays with the card you pick), I'll pay myself (you take over its screen) or Decline, in the app or with one tap on Telegram.
• Phishing-proof by design. A saved login only fills on its own site; an approved card only on the site you approved.
• Stays signed in. Each agent's browser keeps your sessions between tasks until the site signs you out. One-time codes you reply to the Telegram bot go straight into the vault, not the chat.

Real browsing, from your own connection. Agents' machines run on your computer, so sites see an ordinary home connection rather than a data center — no blocked sites, far fewer CAPTCHAs.

You need: a computer with about 4 GB of free disk, and an API key for at least one model provider. The setup installs everything else. Firecrawl (fast web search) is optional.

Already cloned the repo? Run ./setup.sh on macOS/Linux, or double-click setup.cmd on Windows.

The setup asks once, then does the rest:

1. Installs what's missing — Git, Node.js, and Docker (Docker Desktop through winget on Windows or Homebrew on macOS; Docker Engine through get.docker.com on Linux).
2. Clones Xiryn into ./xiryn and installs its packages.
3. Starts Docker and builds the agents' desktop image — a few minutes, once.
4. Creates .env and starts Xiryn at http://127.0.0.1:6796.

The first time, Docker Desktop may ask you to accept its terms, and on Windows it can ask for a restart to turn on WSL 2. Afterwards run the setup again; it skips everything that's already done.

Using Claude Code, Codex, Cursor or another coding agent? Paste this prompt into it. It installs everything, asks you for your keys and starts Xiryn:

Install and start Xiryn for me — the open-source personal agent that runs on my own computer: https://github.com/SouravBeraAkaSpeed/xiryn

1. From my home folder, run Xiryn's setup without prompts. It clones Xiryn into ./xiryn (or reuses it), installs Git, Node.js and Docker if they're missing, installs the packages and builds the agents' desktop image, which takes several minutes the first time — let it finish:
   - macOS / Linux:  curl -fsSL https://raw.githubusercontent.com/SouravBeraAkaSpeed/xiryn/main/setup.sh | XIRYN_YES=1 XIRYN_NO_START=1 bash
   - Windows (PowerShell):  $env:XIRYN_YES="1"; $env:XIRYN_NO_START="1"; irm https://raw.githubusercontent.com/SouravBeraAkaSpeed/xiryn/main/setup.ps1 | iex
   (If you'd rather not pipe a script, clone the repo and run ./setup.sh or .\setup.ps1 inside it with the same two variables.)
   - If it stops and shows a command that needs my password, show me that command, wait for me to run it in my own terminal, then run the setup again.
   - If Docker Desktop was just installed or isn't running, ask me to open it and accept its terms (Windows may also ask for a restart). Wait until `docker info` works, then run the setup again.
   - Node.js may have been installed into ~/.xiryn/node/bin; add that to PATH in your shell if `node` isn't found.

2. Ask me for my keys. Explain each in one sentence with where to get it, and let me skip the optional ones:
   - Required, at least one model provider: OpenAI (OPENAI_API_KEY, platform.openai.com/api-keys), Anthropic (ANTHROPIC_API_KEY, console.anthropic.com), Google Gemini (GOOGLE_GENERATIVE_AI_API_KEY, aistudio.google.com/apikey) — or any other provider listed in .env.example, including a local Ollama or LM Studio.
   - Optional: FIRECRAWL_API_KEY (firecrawl.dev) for fast web search.
   - Optional: TELEGRAM_BOT_TOKEN to talk to my agents from my phone. Tell me how to get it: in Telegram, message @BotFather, send /newbot, choose a name and a username ending in "bot", and copy the token it replies with.
   Put what I give you into the matching lines of xiryn/.env. Never repeat the keys back to me, log them or commit .env.

3. Start Xiryn with `npm run dev` inside the xiryn folder, in the background. Wait until http://127.0.0.1:6796 responds, then open it in my browser.

4. Finish with a short summary: what got installed, which keys are set, how to start Xiryn next time (cd xiryn && npm run dev), and — if I added a Telegram token — that I should open Settings → Remote access in Xiryn and scan the QR code with my phone to pair it.

git clone https://github.com/SouravBeraAkaSpeed/xiryn.git
cd xiryn
npm install
npm run setup     # checks Docker, builds the agents' desktop image, creates .env
npm run dev

Paste a model provider key into Settings in the app — or put it in .env:

OPENAI_API_KEY=sk-...          # or any other provider
FIRECRAWL_API_KEY=fc-...       # optional: web search & reading

npm run setup:local

cd xiryn
npm run dev                    # or: npm run build && npm start

Open http://127.0.0.1:6796 and deploy your first agent. Prefer containers all the way down? docker compose up -d runs Xiryn itself in Docker too.

Click alerts in the status bar once to allow desktop notifications: you'll hear a chime and get a notification whenever an agent finishes, fails or needs you — even with Xiryn in the background.

npm run background              # starts Xiryn with no terminal or browser needed
npm run background -- login     # …and whenever you log in to this computer
npm run background -- stop      # stop it (status, restart and no-login work too)

It serves a production build on 127.0.0.1, built once and again after each update, and logs to data/xiryn.log. Agents, routines and Telegram keep working with every window closed; with no Xiryn tab open, your computer itself shows a notification when an agent finishes or needs you.

When something new is pushed, an update button appears next to the Xiryn logo; it brings you here.

cd xiryn
git pull
./setup.sh        # Windows: setup.cmd

setup installs any new packages and rebuilds the agents' desktop image if it changed (each agent's machine moves to it the next time it starts, keeping its files). Then start Xiryn as usual with npm run dev.

cd xiryn
git pull
docker compose up -d --build

Your data — data/xiryn.db, the vault and the agents' home folders — is untouched by updates.

1. In Telegram, message @BotFather → /newbot → copy the token.
2. Paste it in Settings → Remote access.
3. Scan the QR code with your phone and tap Start.

Done — only your account can use the bot.

/agents   pick an agent or squad      /new     start a fresh thread
/stop     interrupt the agent         /status  what's running

When an agent needs you — a payment, a login, a code — the bot pings you with a live link to the agent's desktop. Finish the step from your phone, reply "done", and the agent carries on. Longer tasks you started at your computer report back here too when they finish, so you can walk away.

Full walkthrough: docs/telegram.md.

Tasks your agents do on their own, on a schedule — while you sleep, with the browser closed.

• Just ask. Tell any agent "every weekday at 9, check for new jobs that fit me" or "tomorrow at 7, remind me to call the bank" — it schedules the routine itself. Ask it to list or cancel them the same way.
• Or set it up on the Routines page: who does it, what to do each time, and when — every day, weekdays, one day a week, every few hours, or just once. Start from ideas like a morning news brief, job alerts, a price watch, a weekly research digest or a plan for the week.
• Results come to you. Each routine has its own thread. When a run finishes you get an in-app notification, a desktop notification when no tab is open, and a Telegram message if it's paired — reply there to follow up.
• Runs on your computer. Times are your computer's local time, and Xiryn has to be running: npm run background -- login keeps it that way. A run missed while the computer slept still happens if it's back within a few hours.

Open Templates in the sidebar, pick one, and change anything before it goes online. Each gets its own desktop and memory.

Squads in one click: Crew (Atlas, Vega, Rigel, Lyra), Launch crew (Vega, Sirius, Antares), Trip team (Polaris, Altair, Mira) and Dev team (Rigel, Arcturus, Electra).

After a few finished tasks Xiryn asks, once, how it's going. Your answer opens a draft in your own email app to souravberaofficial@gmail.com — nothing is sent by Xiryn itself. You can also write any time from the mail icon in the sidebar, or open an issue.

graph LR
    you([You · browser]) -->|localhost| app
    phone([You · Telegram]) -.->|Bot API| tg[Telegram]
    tg -.->|long-poll from your machine| app

    subgraph machine [Your computer]
        app[Xiryn · Next.js server]
        app --> runtime[Agent runtime]
        app --> db[(SQLite · data/xiryn.db)]
        runtime --> db
        runtime -->|docker| ws[Workstations · one container per agent]
    end

    runtime -->|your key| llm[Model provider]
    runtime -.->|your key, optional| firecrawl[Firecrawl]
    you -->|live desktop · noVNC on 127.0.0.1| ws

One process, one file. The Next.js server serves the UI, runs agent turns in-process through the AI SDK, and owns the SQLite database — no queue, no worker, no backend of ours. Details in docs/architecture.md.

Every setting can come from .env or from Settings in the app. Values saved in the app win, are stored only in data/xiryn.db, and are shown back to the browser masked. The annotated list is in .env.example; providers are covered in docs/providers.md.

Xiryn has no user accounts, so it's built never to be reachable by anyone but you:

• Binds to 127.0.0.1 only, and refuses any request whose Host or Origin isn't loopback — which also blocks DNS-rebinding attacks from web pages you visit.
• API keys never reach the browser; the UI only sees masked values, and keys are kept out of logs.
• Telegram answers exactly one paired account; pairing codes are single-use and rotate after wrong guesses.
• Agents execute only inside their own containers — never on your desktop or in your files. Their browsers have password saving and card autofill switched off.
• Saved logins, cards and personal details are encrypted (AES-256-GCM) with a key your operating system's keychain holds. Agents get masked hints only; Xiryn types values into pages itself, logins only on their own site, payment details only after you approve that payment.
• Each live desktop is published on 127.0.0.1 only and asks for its own random password.
• No telemetry. No analytics. The only request Xiryn makes on its own is an update check against GitHub's public API when you open Xiryn, sending nothing about you. Switch it off in Settings → System or with XIRYN_UPDATE_CHECK=off.

See SECURITY.md for the full model and how to report a vulnerability.

Does an agent control my computer? No. Everything an agent does — commands, files, mouse, keyboard, browser — happens inside its own Docker container: a separate Linux system with its own desktop and files. It can't see your screen, files or apps, so you keep using your computer normally. It does share your CPU and memory while it works; the limits are in Settings.

Can it book a flight or order something? It can do the legwork on real websites — search, compare, fill in the details — and it will ask before anything irreversible. Payments always need your approval: the agent shows you the merchant, the amount and the site, and you either let it pay with a card or UPI ID from your vault, or take over its screen and pay yourself — in the app or from your phone through Telegram. Logins work the same way: a saved login is filled for it, or you sign in on its screen once and the session stays.

How do I delete a thread? Hover it under Recent threads in the sidebar and click the trash icon, or open the thread menu (⋯) in its header → Delete thread. The agent, its memory and its workstation stay.

Where is my data? In data/xiryn.db on your disk. Back it up by copying the file; erase everything by deleting it.

Does it work without Docker or Firecrawl? Without Docker, agents chat, remember and (with Firecrawl) research, but can't run code or use a desktop. Without Firecrawl, they search and read the web with their own browser. The app tells you what's missing.

Can I use only local models? Yes — npm run setup:local sets up Ollama and a model in one go, or use Settings → Local models. LM Studio works too: point LMSTUDIO_BASE_URL at it and pick a model with tool calling.

Does it keep working when I close the browser? Yes. Agents run in the Xiryn server, not the page: close the tab mid-task and it carries on. Run npm run background and you can close the terminal too; routines run on time and you're notified when they finish.

What does it cost? Xiryn is free and MIT-licensed. Agents' machines run on your own computer, so they cost nothing, and so do local models. Your model provider (and Firecrawl, if you use it) bill you directly: every reply shows what it cost, the Usage page adds it up per day, model and agent, and an optional monthly budget pauses paid models when it's reached.

Ideas we're exploring — not shipped yet. Have opinions? Open an issue.

• Scheduled and recurring tasks — routines
• More remote channels: WhatsApp, Discord, Slack
• MCP connectors for email, calendar and docs
• Voice in and out
• Shareable agent templates (16 built in today)

Contributions are welcome — from typo fixes to new providers. Start with CONTRIBUTING.md, and please follow the Code of Conduct.

npm run check    # typecheck + lint + format
npm run build

Built by Sourav Bera. If Xiryn is useful to you, a ⭐ helps other people find it.

MIT © 2026 Sourav Bera

_{Muse, Grok Bot, Dots and OpenClaw are trademarks of their respective owners. Xiryn is an independent project and is not affiliated with or endorsed by Meta, xAI, OpenAI or the OpenClaw project.}