Open-source full-stack desktop AI agent
Full-stack AI agent for coding, files, terminals, tools, research, content, multimodal work, and multi-agent workflows worldwide.
简体中文 · English · Docs · Release Notes · Issues
Lime is more than a chat box: it understands context, calls tools, edits files, runs commands, organizes material, creates deliverables, and keeps moving a task forward from one desktop workspace.
Table of Contents
Lime is an open-source full-stack desktop AI agent for users and teams worldwide. It brings the Agent loop, filesystem, terminal processes, code changes, tool calls, MCP, Skills, multimodal input and output, model routing, and multi-agent collaboration into one traceable task chain.
It belongs to the same category of hands-on agents as Claude Code, WorkBuddy, and Codex, while emphasizing a desktop GUI, visual workspace, configurable providers, and mixed engineering, research, and content workflows for global users and teams.
Lime works by:
- Understanding the goal, repository, files, history, and constraints before proposing an executable plan.
- Reading and writing files, searching, applying patches, running terminal commands, testing, and calling tools within granted permissions.
- Projecting work as Thread, Turn, Item, and reusable artifacts so tasks can be paused, reviewed, restored, and continued.
- Letting you choose providers and models without losing the surrounding task context.
Use Lime as an engineering partner, research assistant, content collaborator, or automation executor: you provide the goal and boundaries, and it turns them into inspectable actions and results.
- Code understanding and changes: inspect repositories, locate bugs, implement cross-file features, refactor, add tests, produce patches, and explain diffs.
- Terminal and process operations: run scripts, builds, tests, dependency commands, long-running processes, and inspect their output within controlled permissions.
- Files and workspaces: read and write text or structured files, organize directories, and create documents, reports, web drafts, and other artifacts.
- Tools, MCP, and Skills: discover capabilities, call external tools or local Skills, and turn repeatable procedures into reusable execution units.
- Multimodal understanding and generation: work with text, code, images, screenshots, audio, video, PDFs, tables, and structured data in one task, then create images, audio, video, documents, charts, and other artifacts.
- Research and content delivery: work with web pages, references, screenshots, images, audio, video, and multi-turn context from analysis through publish-ready output.
- Multi-agent and long-running work: split subtasks, make progress in parallel, preserve state, and resume complex work in the same Thread.
- Provider and model control: choose models per task and manage capability catalogs, credentials, routing, retries, and failure boundaries.
Give Lime a repository and an error. The Agent reads the relevant files and configuration, traces the call path, states its assumptions, changes the implementation, runs focused tests, and shows the diff.
Continue in the same Thread with questions such as "why this change?" or "what are the edge cases?" Every step remains visible and reviewable.
Lime can split a requirement across the frontend, App Server, Rust runtime, protocol, and tests, then execute in dependency order. Approve risky actions, pause, revise the plan, or inspect uncommitted changes at any point.
Add web pages, notes, screenshots, meeting records, and prior results. The Agent can structure them, identify gaps, produce a report, script, plan, or launch draft, and keep context for review.
Encode a recurring check, release step, research method, or team rule as a Skill. The Agent can discover and run it through MCP or controlled capabilities instead of repeating every instruction in every prompt.
Delegate research, implementation, testing, and documentation to different agents. The main Thread keeps shared context, permissions, and review boundaries while it collects the results.
Enter a goal, repository, directory, or set of materials. The Agent establishes context first, then proposes a plan and the boundaries that need your approval.
Conversation, plans, file changes, command output, tool results, and artifacts stay around the same Thread. Approve, reject, retry, continue, or restore work step by step.
Lime does not lock you to one model service. Configure providers, models, and credentials, then extend the Agent through MCP, Skills, and controlled tools.
- Developers who need to read code, change code, run tests, and ship features.
- Full-stack teams handling product, design, data, documentation, and automation together.
- Researchers and creators who need local material, terminal tools, and long-running reasoning.
- Teams that want to encode rules, checks, and tools as reusable Skills.
- Users who want a desktop GUI with the working style of Claude Code, WorkBuddy, or Codex.
Lime belongs to the full-stack AI agent, coding agent, desktop AI agent, and terminal agent category for users and teams worldwide. It handles code tasks as well as research, writing, material organization, automation, and multimodal delivery; the goal is a set of verifiable actions, not just a generated paragraph.
Multimodality is a core Agent workflow, not a separate attachment feature. One Thread can combine a written brief, a codebase, images and screenshots, voice or video material, PDFs, and spreadsheets so the Agent can cross-understand them, call tools, and produce delivery-ready results.
Download the installer for your platform from Releases.
- macOS users can download the
.dmgpackage or install with Homebrew. - Windows users can download
Lime_*_x64-setup.exe. - Lime currently publishes macOS and Windows builds only. Linux desktop builds are paused.
- If Windows SmartScreen appears, it usually means the installer is unsigned or has not built enough signing reputation. It does not necessarily mean the installer is broken.
macOS users who use Homebrew can run:
brew tap aiclientproxy/tap
brew install --cask lime- Open Lime, configure a Provider, and test a model connection.
- Choose a workspace or project directory and confirm file and terminal permissions.
- Create an Agent Thread with a goal, constraints, and acceptance criteria.
- Ask for a plan first, then approve file changes, commands, or external tool calls as needed.
- Inspect the diff, test results, and artifacts; continue the task or close it.
- Desktop framework: Electron, Rust App Server, App Server JSON-RPC.
- Agent runtime: Thread / Turn / Item projection, tool lifecycle, Skills, MCP, multi-agent work, and history restoration.
- Frontend: React, TypeScript, Vite.
- Local capabilities: filesystem, processes, workspaces, artifacts, and persisted state.
- Supported platforms: macOS, Windows.
- License: GPLv3.
No. Lime is an Agent host and workspace, not a model vendor. Configure an available Provider, model, and credential.
Yes. Within the permissions you grant, the Agent can read and edit files, run terminal commands, run tests, and call tools. Review or approve high-risk actions.
Project materials, conversation history, and configuration are kept locally by default. Inputs needed for model or external-tool calls are sent to the Provider or target service you configured; follow the relevant service policy for sensitive material.
Normal chat mainly returns text. Lime understands workspace context, operates files, processes, and tools, retains execution state and results, and lets you keep moving in the same task.
No. Describe the goal, constraints, context, and acceptance criteria. Reusable procedures can become Skills, and complex tasks can start with an Agent-generated plan.
GNU General Public License v3 (GPLv3)
This project is provided for learning and research purposes only. Users are responsible for their own use and risk.
Lime does not directly provide AI model services. Model capabilities are provided by third-party AI service providers configured by the user.