A desktop AI coding environment whose memory works like yours — it surfaces what matters before you ask, instead of waiting to be searched. With dual agents and granular control over every action.
Refactor the auth module to use JWT tokens
I will refactor the auth module. Let me check the current implementation first.
Done. Created a jwt.ts with sign/verify helpers and updated the middleware to validate tokens. Session storage is now replaced with stateless JWT.
Human-like memory
Most AI “memory” is a tool you have to call: a box you search, a “save this” button you press. Loom’s memory behaves like yours — it surfaces on its own, keeps what matters, and organizes itself while you work.
Relevant context appears every turn — no recall step. The way a memory comes to you, not one you go hunting for.
What you rely on stays sharp; what you never touch quietly fades. Your memory stays signal, not clutter.
Just by talking, conversations sort into topics, knowledge, and entities. There is no “add to memory” chore.
When facts change, Loom links and reconciles them into a graph instead of stacking contradictions. Ask “is this still true?” and get a straight answer.
Agent workspace
Loom isn't a chat box bolted onto a CLI. It's a desktop workspace where you and your agents share the same browser, terminal, git, and board — so the agent works with what you actually see, not a description of it.
A real Chromium browser lives inside Loom. Your agent reads the same network log, request bodies, and console errors you do — no screenshots, no copy-paste. Pick an element off the page and hand it straight into the conversation.
Run a session per task and let them message each other. A Super Agent dispatches work and routes context between them — a team, not a single thread.
An embedded terminal on the session's working directory. You and the agent see the same output stream, live.
Branch lanes, inline diffs, staged hunks, one-click push — with a commit message the agent drafts for you.
The agent runs tests in the terminal and checks the result in the browser — failures surface in the same window they were written in, so changes are verified, not assumed.
Drop cards on a Kanban board and assign them to an agent — or let it dispatch the work itself — and watch them move across columns.
Docs and HTML render live as the agent writes them. Click any element in a preview to hand it back into the conversation.
Features
A Project Agent handles code in your repo while a Loom Assistant coordinates, plans, and manages GitHub. They work together seamlessly.
Just by talking, conversations self-organize into topics, knowledge, and a graph — there is no 'add to memory' step. The right context surfaces on its own, so your AI already remembers what you built last week.
Visual commit graphs with branch lanes, AI-generated commit messages, inline diffs, and a full staging workflow built right in.
Three permission modes from cautious to autonomous. Allow-list specific tools per project. Every action is visible and logged.
On-device model powers semantic search across all your memory. Nothing leaves your machine. Privacy by architecture.
Direct filesystem access, integrated terminal, and system-level integration. Not a browser tab, a real development environment.
Dual Agents
The Project Agent lives inside your repo, it reads, writes, and executes code. The Loom Assistant lives above the code, planning, asking questions, and orchestrating work across sessions. They message each other, so context stays coherent.
Hands-on coding in your repository
Orchestration and project oversight
Full Q&A history preserved and searchable
Auto-clustered themes from your work
Extracted facts reusable across sessions
Memory
Every exchange is automatically segmented into topics, distilled into reusable knowledge, tagged, and linked into a graph of entities — no manual step. The right pieces surface on their own each turn, so your AI recalls what you built three weeks ago, not just this turn. Full-text and on-device semantic search are there for when you do want to look yourself.
Any model
Claude Code and Codex both run first-class. Switch models mid-conversation — even mid-task — and your memory, context, and history stay exactly where they were. Models are interchangeable; what you have built up is not.
Move between runtimes without restarting or losing context.
Every turn records which model wrote what, so traces never blur.
Git workflow
Visual commit graphs with true branch lanes. AI-written commit messages based on the actual diff. Inline staging, worktree-based session forks, and a full merge workflow. No more context-switching to the terminal for routine git.
Security
Three permission modes let you tune the balance between speed and safety. Override globally or per-project, and allow-list individual tools.
Ask permission for all tools. Full visibility into every action.
Auto-approve file reads and writes. Pause for shell commands.
Auto-approve everything. Maximum speed for trusted workflows.
FAQ
Loom is in early access. Leave your email and we will get you set up.
No spam. Invite-only access for now.