Alysis Code

A from-scratch terminal and desktop AI coding agent with a built-in sandbox, free web search and computer use.

Stars
★ 210
Last updated
2d ago
License
Apache-2.0
Primary language
Python

At a glance

How it runs
CLIDesktop appIDE extension
Works with
Universal · cross-platformOpenAI API · Claude APICodex · Claude Code (Partial support)
Cost
Free tier plus a paid hosted plan
Setup effort
Medium · a few setup steps
You'll need
Python 3.11+uv (auto-installed by installer)Seatbelt/Bubblewrap/Docker sandbox backendShell / CLINetwork accessLocal filesystemMCP Server
Typical use
Solo developers who want an agent to edit a local repo, run tests and review each diff
Not a fit if
  • Teams needing a Linux desktop app (CLI only on Linux)
  • Users who need unrestricted, unsandboxed shell execution
  • Users unwilling to bring a key or use Alysis account credits
Source review
71/100 · Some gaps

What does this agent do, and when should you use it?

Alysis Code is an independently built (not a fork) open-source AI agent that ships as a terminal CLI and as macOS/Windows desktop apps. It connects to OpenAI, Anthropic, Gemini, DeepSeek, OpenRouter, xAI and other providers, or to any OpenAI-compatible endpoint such as Ollama, LM Studio or vLLM; you can bring your own key, run local models, or use an Alysis account with free credits. The differentiator is the execution layer: shell commands run by default in a sandbox enforced outside the model (Seatbelt on macOS, Bubblewrap or Docker on Linux/WSL, a native Windows x64 sandbox), with readonly/review/auto/fullaccess permission levels and code/architect/ask/debug personas. Free web search and computer use are built in, and the desktop app adds Work document tools, Projects, Browser, Scheduled, Customize and Forge, with VS Code and JetBrains extensions under extensions/. Outputs include code diffs, command results, checkpoint rollback, and Forge's reviewed multi-task plans.

Running alysis in a project directory starts the agent, which reads workspace files, calls the selected model and uses tools to execute shell commands, read/write files and run verification commands; shell and verification commands go through the sandbox by default, verifiable via alysis sandbox doctor --smoke. Permissions are switched with Shift+Tab across readonly, review, auto and fullaccess, and personas can only narrow—never widen—what the agent may do. On desktop, attachments (notes, CSV) become Word, spreadsheet, presentation or PDF output; the Code view shows diffs in Changes, runs commands in a built-in Terminal and rolls back to checkpoints. MCP servers, skills, plugins and hooks extend the agent through Customize, and Forge decomposes a goal into dependent tasks each with its own checks.

  1. Solo developers who want an agent to edit a local repo, run tests and review each diff
  2. Privacy-sensitive teams using Ollama or LM Studio locally who still need command isolation
  3. Office users who want Word, Excel, PowerPoint or PDF output directly from a chat
  4. Developers who want the same engine inside VS Code or JetBrains
  5. Desktop users scheduling recurring tasks (daily, weekdays, weekly or hourly)

How do you install or deploy this agent?

On macOS, Linux and WSL the installer sets up uv and its own Python, with no Python or admin rights required:

curl -LsSf https://raw.githubusercontent.com/AlysisAi/AlysisCode/main/scripts/install.sh | sh

On Windows PowerShell:

irm https://raw.githubusercontent.com/AlysisAi/AlysisCode/main/scripts/install.ps1 | iex

With Python 3.11+ already available, use a package manager:

uv tool install alysis-code
pipx install alysis-code

Upgrade with alysis update. The desktop app is a macOS (.dmg, Apple silicon) or Windows (.exe, x64) installer from alysiscode.com and bundles the engine, so no Python or CLI install is needed. There is no Linux desktop build yet.

How do you use this agent?

Start the CLI from a project directory:

alysis

The first run walks you through connecting a model, picking a workspace and checking the sandbox; rerun it with alysis setup. Choose your own key (OpenAI, Anthropic, Gemini, DeepSeek, OpenRouter, xAI and others) or point at an OpenAI-compatible endpoint such as Ollama, LM Studio or vLLM, or sign in with alysis login for an Alysis account (50 free credits every 30 days). Switch permission levels with Shift+Tab. Verify your sandbox backend:

alysis sandbox doctor --smoke

In the desktop app, both model paths live under Models & keys in the account menu.

What are this agent's strengths and limitations?

Pros
  • Sandbox enforced outside the model by default, with a alysis sandbox doctor --smoke self-check.
  • Model-agnostic: multiple cloud providers, OpenAI-compatible endpoints and local models, switchable per task or per role.
  • Clear permission model with readonly/review/auto/fullaccess, plus personas that can only narrow scope.
  • One engine across CLI, desktop app and VS Code/JetBrains extensions, with Forge producing reviewed multi-task plans.
  • Built-in free web search and computer use, so networking works without an extra API key.
Limitations
  • Desktop builds exist only for macOS (Apple silicon) and Windows (x64); Linux users get the CLI only.
  • Pay-per-use costs depend on the chosen provider or Alysis credits, so long-term spend needs assessment.
  • Requires a sandbox backend (Seatbelt, Bubblewrap/Docker, or Windows native); strict mode refuses execution when none is available.
  • Forge is documented as token-hungry and should be started on small tasks.
  • The project is new; the JetBrains extension is labeled preview and community material is still growing.

How does this agent compare with similar options?

The README notes that the shared editor sidebar includes MIT-licensed adaptations from Kilo Code and OpenCode and that projects and history can be imported from other coding agents, but it makes no feature comparison, so no substitute relationship should be inferred.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Alysis Code This agent 71 · Some gaps CLIFreemium ★ 210 2d ago Python OpenAI API · Claude API
Devo Desktop Coding Agent 58 · Major gaps Desktop appFree + model costs ★ 345 1d ago Rust OpenAI API · Claude API
Synara 52 · Major gaps Desktop appFree + model costs ★ 2.2k 1d ago TypeScript Codex · Claude Code
VT Code 66 · Some gaps CLIFree + model costs ★ 898 2d ago Rust OpenAI API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
71/ 100 5-point scale 3.6 / 5
Trust 21/29
Reliability 9/14
Adaptability 15/18
Convention 14/18
Effectiveness 7/13
Verifiability 5/8
Why each dimension lost points
Trust21 / 29 · 3.6/5

The security model documentation gives specific and consistent descriptions of least privilege (four tiers readonly/review/auto/fullaccess, personas can only narrow and never widen, sandbox defaults to strict and refuses execution when no backend is available) and user confirmation (write operations and shell commands require approval, credential files and directories outside the project force manual approval), so it scores high. Data-flow transparency covers SSRF protection, web_fetch source gating, and omission of MCP descriptions, but lacks a complete user-facing data-flow/telemetry explanation, so points are deducted. Sensitive data handling mentions an encrypted provider vault, tokens not stored in config.json, and environment variable cleanup, but has no key rotation/audit details, so it is only moderate. For dependency security, pyproject has lower-bound constraints and CI has npm audit and lock synchronization, but most dependencies are lower-bound only with no hash-lock evidence, so points are deducted. External effects include the sandbox network being off by default and LAN preview requiring approval, but fullaccess removes the sandbox and approvals, leaving a large risk surface, so points are deducted. Rollback is only mentioned via desktop checkpoint and Changes, with no clear CLI-side rollback mechanism, so it scores low. Source attribution includes NOTICE and third-party Kilo Code/OpenCode declarations, but only in the editor sidebar, so coverage is limited.

Reliability9 / 14 · 3.2/5

README, quickstart, security_model, and shell_sandbox are basically consistent on mode naming and defaults, but README uses readonly/review/auto/fullaccess while security_model uses the TUI mapping read/safe/fast/full, so terminology is slightly inconsistent and points are deducted. Dependency declarations are clear and the Python version matrix 3.11–3.14 is covered in CI, but most dependencies are lower-bound constraints with no lock-file hash evidence, and some version numbers (e.g. certifi>=2026.10.19) are unusually advanced, raising availability questions, so points are deducted. The documentation describes sandbox doctor, a troubleshooting table, and fail-closed behavior, but lacks direct evidence of runtime error message formats and diagnosability, so it is only moderate.

Adaptability15 / 18 · 4.2/5

It clearly targets terminal and desktop users and covers coding, research, documents, browser, scheduled tasks, and other scenarios, so audience and scenario descriptions are sufficient. security_model and shell_sandbox explain capability boundaries in detail (the sandbox does not cover custom tools, fullaccess is not a sandbox boundary, Windows backend limitations), so boundaries are clear. There are trigger controls such as web_search_policy, persona, and permission modes, but no systematic explanation of tool trigger precision and false triggers, so points are deducted. It covers macOS/Linux/WSL/Windows multiple backends, but Windows is beta, Docker does not support additional folders, and there is no Linux desktop version, so environment fit has gaps and points are deducted.

Convention14 / 18 · 3.9/5

The docs directory structure is clear and README has navigation, but some links point to external sites and the in-repo documentation index is limited, so points are deducted. Installation notes are very detailed, covering multiple platforms, package managers, upgrades, and PATH handling, so it scores high. Command aliases alysis/alysis-code are stable, but permission modes have two naming schemes in the documentation, slightly affecting stability. There are quickstart and command examples, but no dedicated FAQ section, so points are deducted. shell_sandbox and windows-cli-sandbox have dedicated Limitations sections, so the explanation is sufficient. The full Apache-2.0 LICENSE text is consistent with pyproject metadata, so it scores high. pyproject version is 0.16.1, quickstart mentions 0.15.2, and a CHANGELOG link exists, but no changelog content evidence is provided, so points are deducted. Publisher identity is unverified, and maintenance responsibility and update paths rely only on external sites and Discord with no clear governance explanation, so it scores low.

Effectiveness7 / 13 · 2.7/5

There are usability designs such as diff, Changes, checkpoint, and document output, but no actual evidence of output quality, so it is moderate. Differentiation is clear through multiple models, sandbox, Forge, and document tools, but there are many similar competitors, so marginal value is moderate. Forge explicitly consumes a large number of tokens and hosted accounts use a credit system, so cost information is limited and may be high, so points are deducted.

Verifiability5 / 8 · 3.1/5

Security and sandbox claims mostly point to specific files (read_only_commands.py, command_review_rules.py, etc.), so traceability is relatively good, but some claims have no corresponding file evidence, so points are deducted. README, security_model, and shell_sandbox corroborate each other, but there is no test or code-level cross-validation, so it is moderate. The documentation distinguishes facts from recommendations (e.g. "does not replace code review"), but some performance/security claims lack supporting evidence, so points are deducted.

Risks and how to mitigate them
  • Publisher identity is unverified; maintenance responsibility and update path are unclear—verify provenance before enterprise adoption.
  • fullaccess mode removes the sandbox and approval prompts; use only in trusted workspaces.
  • Dependencies are mostly lower-bound pins with some unusually advanced version numbers; lock and audit dependencies independently.
  • The Windows sandbox backend is beta and Docker does not support additional folders, leaving cross-platform gaps.
  • Rollback evidence on the CLI side is thin; back up before critical operations.
Evidence confidence: Low Reviewed Nov 06, 2026 Reviewed revision 6c2db49b45d8
See the full review method →

FAQ

Do I have to pay to use it?
No. Bring your own model key and pay per use, run a local model via Ollama, or sign in with alysis login for 50 free credits every 30 days without a card.
Are commands actually isolated?
By default yes: shell and verification commands run in a sandbox enforced outside the model (Seatbelt on macOS, Bubblewrap/Docker on Linux/WSL, native sandbox on Windows x64), and strict mode refuses execution with no backend. Check with alysis sandbox doctor --smoke.
Which models can I use?
OpenAI, Anthropic, Gemini, DeepSeek, OpenRouter, xAI and others, plus any OpenAI-compatible endpoint such as Ollama, LM Studio or vLLM.
Is there a Linux desktop app?
Not yet; Linux and WSL users run the CLI.
Will Forge get expensive?
The README warns that Forge uses a lot of tokens and recommends starting small.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents