Just Another Intelligent Tool
An AI agent workspace that runs on your machine.
Jait is one small gateway you install yourself. It gives an agent real terminals, your filesystem, a controllable browser, live previews, memory, and scheduled jobs — then lets you reach all of it from your laptop, your server, or your phone. Your code never leaves your disk, and you bring whichever model you already pay for.
Use Codex, Claude Code, Gemini, OpenCode, Copilot, Ollama, LM Studio, or any OpenAI-compatible endpoint while Jait keeps tools, previews, files, and prompts in one workspace.
Guarded tools that can actually work
Run terminals, node tools, file edits, SSH prompts, previews, and browser sessions with approval where it matters.
Parallel agent threads
Manager and swarm modes split work across background threads while preserving repos, change counts, and task history.
Reach it from anywhere
Polished web, desktop, and mobile clients, plus WhatsApp channel replies and remote node deploys that link other machines as filesystem nodes.
Actual Jait interface
Refactor the auth middleware to support JWT refresh tokens
I'll update the middleware and add a refresh endpoint.
Auth middleware now validates and rotates refresh tokens. All types check out.
Jait, with a real project open
The complete logged-in workspace in editor mode. The screenshot follows your light or dark theme choice.
Install the gateway
One command to install Jait globally on your machine.
Start the server
The gateway boots with auth, tools, scheduler, memory, and preview support.
Connect from anywhere
Open Jait from desktop, mobile, or another browser on your network.
Choose a provider
Use API keys, local models, or trusted CLI providers from the same project.
Describe your project
Tell the agent what to build; it handles tools, files, previews, and tests.
Coordinate follow-ups
Review diffs, schedule jobs, delegate threads, and keep iterating.
http://localhost:8000
Connect to Gateway
Use localhost or a network URL from any browser.
Provider
localhost:8000
Create a new Express API with TypeScript, JWT auth, and a SQLite database
I'll scaffold the project, run tools, and open a preview.
What Jait can actually do today
Not a roadmap — this is the tool surface shipping in v0.1.708. The agent picks from 64 built-in tools, and every one of them runs on your machine.
Code, files & repos
Read, write, and patch files with backup and restore. A code-graph index answers "what calls this?" across large repos, ranked search spans the gateway and any attached machines, and it can generate architecture diagrams from the code itself.
file.readfile.writefile.patchcodegraph.queryarchitecture.generateReal terminal execution
Full PTY terminals, not a sandboxed echo. The agent runs builds and tests, streams output live, and can target a specific terminal you point it at. Elevated commands and installs ask first.
jait.terminalterminal.runterminal.streamelevated.runos.installBrowser control
A Playwright-driven browser the agent can actually use — navigate, click, type, scroll, pick from dropdowns, and read structured page snapshots instead of guessing. There's a sandboxed Chromium container with noVNC when you want it fully isolated.
browser.navigatebrowser.clickbrowser.typebrowser.snapshotbrowser.screenshotLive preview
One call boots your project, proxies the localhost port into the workspace, and hands back a controllable browser session. The agent can click through the app it just changed, read the preview's logs, and restart it — so "does it actually work?" gets answered before you look.
preview.openpreview.inspectpreview.logspreview.restartAgent orchestration
Four modes: Developer for hands-on work, Manager to delegate, Swarm to fan out, Thread for focused side-runs. Sub-agents stream inline, share a todo list, and message each other. Loop backstops and duplicate-call quarantine stop runaway runs.
agent.spawnagent.messagethread.controljait.todosMemory & continuity
Durable memories survive across sessions and projects, and the agent can search everything you've said before or pull the exact trace of an old chat. Drop durable instructions in ~/.jait/SOUL.md and every provider picks them up.
memory.savememory.searchsession.searchchat.tracesJobs, cron & channels
Schedule agents to run on a cron. Have them message you when something finishes or breaks — including through the WhatsApp and Telegram channel assistants, so a long job can reach you when you're nowhere near the machine.
cron.addcron.updatechannel.sendchannel.remindMachines & remote nodes
Attach another machine as a filesystem node and work across both from one chat. Scan your network, SSH into boxes, share or record your screen for visual context, and let the agent speak results out loud.
network.scanssh.runscreen.sharesurfaces.listvoice.speakResearch on the web
Search and fetch pages through whichever backend you configure — Brave, Perplexity, xAI Grok, Gemini, or Moonshot — and hand images straight to a vision model when the answer is in a screenshot.
web.searchweb.fetchimage.viewExtend it
A real MCP SDK bridge pulls in any MCP server you already run, over HTTP or stdio. Skills package repeatable workflows, extensions add integrations, and tool discovery keeps the prompt small by loading schemas only when needed.
MCP bridgeskills.manageextensions.managetools.searchPull requests & Git
Open, inspect, and resolve PRs from the workspace, including merge-conflict inspection and resolution. Every GitHub operation is bound to your encrypted token — never a shared gateway credential.
PR reviewconflict resolutionworktreessource controlConsent where it counts
Destructive and sensitive actions surface an approval card before they run, secrets are masked in tool output, and the gateway enforces ownership checks so one account can't reach another's projects or tokens.
approval cardssecret maskingownership checks
Being straight with you: Jait is young and it still breaks. It's a passion project shipped in the open — 650+ releases so far, and plenty of rough edges left. If something falls over, an issue genuinely helps more than a star. That's the deal.
How it actually works
One process on your machine. No cloud backend, no account with us, nothing to sign up for.
Install the gateway
A single npm package, or the desktop app that bundles everything. Needs Node 22.5+ — that's the whole dependency list.
It runs where your code is
A Fastify server with a local SQLite database in ~/.jait. Your files, chats, and memories are rows on your own disk — you can delete the folder and it's gone.
Open it from any device
The gateway serves a web UI to any browser on your network, plus desktop and mobile clients. The same session streams live to all of them over WebSocket.
Bring your own brain
Point it at a CLI provider you're already signed into, any OpenAI-compatible endpoint, or a fully local model. Jait supplies the tools; you choose the model.
Where the model fits in
Jait isn't a model and doesn't resell one. It's the workspace around it — the tools, approvals, previews, memory, and multi-device plumbing. That means the interesting question isn't "which model does it use", it's "what is the model allowed to touch". You answer that, per action.
Why bother self-hosting an agent
The honest pitch, for people deciding whether this is worth twenty minutes.
Your repo stays on your disk
Files, terminals, and browser sessions never leave the machine. The only thing that goes out is what the model you picked needs to see — and with Ollama or LM Studio, not even that.
No second subscription
Already paying for Codex, Claude Code, Gemini, Copilot, or OpenCode? Jait drives the CLI you're signed into. It adds a workspace, not another bill.
It finishes things, not just answers
Running the test suite, opening the preview, and clicking through the page are all inside the loop. The agent can check its own work instead of handing you a guess.
Start at the desk, finish on the couch
Kick off a long refactor on your laptop and watch it from your phone. Same session, live. Queue a follow-up message and it drains when the current turn lands.
Readable, testable, MIT
Around 250k lines of TypeScript with 300+ test files, in the open. If you don't like how something behaves, the code is right there and PRs are welcome.
Put it on a box and forget it
Ships with a systemd unit. Run it on a homelab server or VPS, reach it from anywhere on your network, and update in place with jait update.
What that looks like in practice
Four things people actually use it for.
"Add refresh tokens to the auth middleware and prove it works."
It edits the files, runs the type-checker and tests, opens the preview, and clicks through the login flow — then shows you the diff with the evidence attached.
"Where does billing state get mutated?"
The code-graph index traces call paths across the repo instead of grepping and hoping, and it can draw the architecture diagram it built along the way.
"Watch the deploy and tell me if it fails."
Installed as a systemd daemon on a homelab box, with a cron job driving the check and a WhatsApp message when something needs you.
"Take these three issues in parallel."
Manager mode fans the work out to background threads on separate worktrees, each with its own diff, so nothing steps on anything else.
Questions you're probably about to ask
The ones that decide whether you install it.
Does my code get uploaded anywhere?
Not by Jait. The gateway runs on your machine and stores everything in a local SQLite database at ~/.jait. There's no Jait cloud, no account with us, and no telemetry service to opt out of. The one thing that leaves is whatever your chosen model provider needs to see — so if you run Ollama or LM Studio locally, nothing leaves at all.
Do I need an API key?
Only if you want to use an API-based model. If you're already signed into a CLI provider — Codex, Claude Code, Gemini CLI, Copilot CLI, or OpenCode — Jait drives that directly and no key is needed. A fully local model works too.
What does it cost?
Jait is MIT-licensed and free. You pay whatever your model provider charges, which may be nothing if you run locally or already have a subscription.
What do I need to run it?
Node 22.5 or newer on Windows, macOS, or Linux, then npm install -g @jait/gateway. If you'd rather not touch npm, the desktop app bundles the gateway and UI in one window.
Can I run it on a server and use it from my laptop?
Yes — that's a first-class setup. jait daemon install registers a systemd user service that starts on boot, and the UI is then reachable from any browser on your network. You can also attach other machines as remote nodes and work across them from one chat.
How much can the agent do without asking me?
You decide. Sensitive and destructive actions raise an approval card before they run, secrets are masked in tool output, and the agent loop has hard backstops against runaway rounds. Everything it does is visible as a tool card in the transcript.
Is it stable enough to rely on?
Not yet, and it would be dishonest to say otherwise. It's early, it breaks, and it changes fast — 650+ releases and counting. It's very usable for day-to-day building if you're the kind of person who files a bug report when something misbehaves. If you need something battle-hardened, wait a few months and check back.
How do I update?
Run jait update, or use Settings → Check for updates → Apply in the UI. Gateways started with jait start or the systemd daemon restart themselves afterwards.
Get started in two commands
Install the gateway, start it, open your browser. Everything else happens in the UI.
Then open http://localhost:8000, create a local account, and pick a provider. Prefer a single window? The desktop app bundles the gateway and UI together — no npm required. Running it on a server? jait daemon install sets up a systemd service that starts on boot.
Every platform
It's better with people breaking it
Jait is a passion project built in the open. The fastest way to make it good is to tell me what fell over.
If you install it and something misbehaves, open an issue — that genuinely helps more than a star. If you want to talk through an idea first, Discord is the quicker route. And if you'd rather just read the code before trusting it with a terminal, that's the most reasonable thing you could do; it's all there.