Fastfold Agent CLI is an agentic research environment for drug discovery and computational biology. Think of it as a coding agent, but for biology. You ask a question in natural language and it plans and executes multi-step scientific workflows using 190+ specialized tools, installable skills, Fastfold Cloud compute, and a persistent Python sandbox. It is intentionally narrow, built for the real, tool-heavy research workflows scientists run rather than for being a general-purpose chatbot.
Our mission is to bring the best tools to scientists wherever they work: on the cloud, on local compute, university HPC, or inside the enterprise.
Under the hood it runs on a Deep Agents (LangChain / LangGraph) agentic loop with Programmatic Tool Calling (PTC) and native progressive skill discovery. A single agent plans, calls domain tools as Python inside a persistent sandbox, self-corrects, and synthesizes a report. Anthropic, OpenAI, and local or OpenAI-compatible models all work through the same loop.
Many of the tools and prompts trace back to CellType; see Acknowledgements for credits.
You get 190+ tools, 30+ database APIs, and multi-step planning, plus what Fastfold adds for composability and extensibility:
- GPU compute models & workflows: run heavy scientific workflows like folding, protein design, and MD simulation on Fastfold Cloud, your own compute, or providers like Modal, Boltzbio, and more.
- Installable skills: discover, add, and share workflows natively (
fastfold skills find,fastfold skills add <github url>). - Any model: Anthropic, OpenAI, or local/open models like Gemma, Qwen, and DeepSeek through endpoints like Ollama, Unsloth, oMLX, DS4, llama.cpp, and LM Studio via
/model,/model-manager, orfastfold setup.
Install uv (for native CLI install)
- Python 3.11+ (recommended: let
uvinstall managed interpreters). - uv — Installing uv. Quick options:
Linux / macOS:
curl -LsSf https://astral.sh/uv/install.sh | shWindows (cmd/PowerShell):
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"Alternatively: winget install --id=astral-sh.uv -e (see Astral docs for other methods).
After installing uv, close and reopen your terminal or PowerShell so PATH picks up the uv executable.
Linux / macOS:
uv tool install "fastfold-agent-cli[all]" --python 3.11Windows (cmd/PowerShell):
uv tool install "fastfold-agent-cli[win_build]" --python 3.11Install via WSL2 + Ubuntu (full [all] stack, recommended)
tiledbsoma does not publish usable native Windows wheels, so [all] on cmd/PowerShell usually fails. Use WSL instead:
- Install WSL (Ubuntu recommended).
- Open an Ubuntu terminal and install
uv+ Python (see Prerequisites above). - Run the same install command inside WSL:
uv tool install "fastfold-agent-cli[all]" --python 3.11docker run -it --rm \
-v fastfold-cli:/root/.fastfold-cli \
fastfold/fastfold-agent-cli:latestThe interactive setup wizard is the easiest way to get started. It lets you pick provider(s) from a toggle list, then enter keys:
fastfold setupTo skip the toggle list, pass the provider(s) explicitly (comma-separated):
fastfold setup --provider anthropic
fastfold setup --provider openai
fastfold setup --provider openai_compatible
fastfold setup --provider anthropic,openaiPrefer environment variables? Set keys directly:
export ANTHROPIC_API_KEY="sk-ant-..."
export OPENAI_API_KEY="sk-..."
export FASTFOLD_API_KEY="sk-..."
export BOLTZ_API_KEY="sk_bc_..."Use /keys (interactive) or fastfold keys (shell) to see integration status, masked previews, config keys, and setup links.
| Service | Env var | Config key | Unlocks | Get key / setup |
|---|---|---|---|---|
| Anthropic | ANTHROPIC_API_KEY |
llm.anthropic_api_key |
Claude model access (default provider) | console.anthropic.com/settings/keys |
| OpenAI | OPENAI_API_KEY |
llm.openai_api_key |
OpenAI model access | platform.openai.com/api-keys |
| OpenAI-compatible | OPENAI_COMPATIBLE_API_KEY |
llm.openai_compatible_api_key / profile key |
Local/self-hosted OpenAI-compatible endpoints | Ollama API docs |
| Fastfold AI Cloud | FASTFOLD_API_KEY |
api.fastfold_cloud_key |
Fastfold cloud skills and integrations | cloud.fastfold.ai/api-keys |
| Boltz | BOLTZ_API_KEY |
api.boltz_api_key |
Boltz API skills (boltz skill modes) |
api.boltz.bio/console |
| IBM RXN | IBM_RXN_API_KEY |
api.ibm_rxn_key |
Retrosynthesis workflows | rxn.res.ibm.com |
| Lens.org | LENS_API_KEY |
api.lens_key |
Patent search workflows | lens.org subscriptions |
| SendGrid | SENDGRID_API_KEY |
notification.sendgrid_api_key |
Email notification delivery | sendgrid.com |
| Lambda Labs | LAMBDA_API_KEY |
compute.lambda_api_key |
GPU compute job submission | cloud.lambdalabs.com |
| RunPod | RUNPOD_API_KEY |
compute.runpod_api_key |
GPU compute job submission | runpod.io |
Boltz quick setup from interactive mode:
/keys set-boltzThat flow prompts for BOLTZ_API_KEY, then offers to install:
- the Fastfold Boltz skill (
fastfold-ai/skills@skills/boltz) - the
boltz-apiCLI (curl -fsSL https://install.boltz.bio/boltz-api/install.sh | sh)
For CI or scripting, pass keys non-interactively:
fastfold setup --api-key sk-ant-... --fastfold-api-key sk-...
fastfold setup --provider openai --openai-api-key sk-... --fastfold-api-key sk-...
fastfold setup --provider anthropic --api-key sk-ant-... --fastfold-api-key sk-... --boltz-api-key sk_bc_...Fastfold supports local/self-hosted OpenAI-compatible endpoints in both fastfold setup and interactive mode.
Recommended setup path:
fastfold setup --provider openai_compatibleInteractive controls:
/model: switch among configured providers/models./model-manager: add/edit/delete profiles, run endpoint health checks, and inspect discovered model IDs.
Backend quick reference:
| Backend | Default endpoint | Model discovery path | Key behavior | Best for |
|---|---|---|---|---|
| Ollama | http://localhost:11434/v1 |
/api/tags |
Usually ollama placeholder key |
Best out-of-box local default on laptops/workstations |
| Unsloth | http://localhost:8888/v1 |
/v1/models |
Requires Unsloth Studio key | Good for optimized local serving with auth |
| oMLX | http://localhost:8000/v1 |
/v1/models |
Typically custom key | Useful for Apple Silicon-focused local inference |
| DS4 | http://localhost:8000/v1 |
/v1/models |
Optional/custom key | DeepSeek v4-style local endpoint profile |
| llama.cpp | http://localhost:8080/v1 |
/v1/models |
Optional/custom key | Lightweight C/C++ runtime for local/server inference |
| LM Studio | http://localhost:1234/v1 |
/v1/models |
Optional/custom key | Easiest GUI-first desktop serving workflow |
| Other gateway | custom | /v1/models then /api/tags fallback |
Provider-specific | Use for vLLM/proxies/self-hosted OpenAI-compatible APIs |
Wizard flow (compressed):
- Choose backend template.
- Confirm/edit endpoint URL.
- Enter API key if required.
- Review profile summary, then pick discovered model (or enter model ID manually).
Use these upstream projects/docs to install and run local or self-hosted LLM inference engines before adding profiles in Fastfold:
- DS4 (DeepSeek v4 Flash/PRO engine): antirez/ds4
- llama.cpp: ggml-org/llama.cpp
- LM Studio OpenAI-compatible server: LM Studio OpenAI Compatibility
- Ollama: ollama/ollama
- oMLX: jundot/omlx
- Unsloth: unslothai/unsloth
Scripted profile setup flags:
fastfold setup --provider openai_compatible \
--profile-label "Custom Gateway" \
--profile-template other \
--profile-endpoint https://gateway.example.com/v1 \
--profile-key sk-... \
--profile-default-model gpt-oss-120b \
--set-default-profileYou can also configure directly:
# Ollama
fastfold config set llm.provider openai
fastfold config set llm.openai_base_url http://localhost:11434/v1
fastfold config set llm.openai_compatible_backend ollama
fastfold config set llm.openai_compatible_api_key ollama
fastfold config set llm.model llama3.1
# Unsloth
fastfold config set llm.provider openai
fastfold config set llm.openai_base_url http://localhost:8888/v1
fastfold config set llm.openai_compatible_backend unsloth
fastfold config set llm.openai_compatible_api_key sk-unsloth-...
fastfold config set llm.model <unsloth-model-id>Environment variables for compatible endpoints:
export OPENAI_BASE_URL="http://localhost:11434/v1"
export OPENAI_COMPATIBLE_API_KEY="ollama"Inside interactive mode:
- Run
/modelto switch across configured providers/models. - Run
/model-managerto add/edit/delete OpenAI-compatible profiles and view endpoint health/model lists.
Provider selection:
fastfold config set llm.provider anthropic
fastfold config set llm.model claude-sonnet-4-5-20250929
fastfold config set llm.anthropic_api_key sk-ant-...
fastfold config set llm.provider openai
fastfold config set llm.model gpt-4o
fastfold config set llm.openai_api_key sk-...
# Legacy fallback (Anthropic only, still supported)
fastfold config set llm.api_key sk-ant-...# Start interactive session
fastfold
# Single query
fastfold "What are the top degradation targets for this compound?"
# Validate setup
fastfold doctor
# List available tools
fastfold tool list
# List loaded skills
fastfold skills listUse this to clone a shared Fastfold Agent thread into your local CLI session history.
fastfold agent fork <share_id>You can pass either a raw share ID or a full shared URL (.../agents/share/<share_id>).
Optional flags:
# Override agents API endpoint (default: https://agents-api.fastfold.ai/v1)
fastfold agent fork <share_id> --agents-api-url http://127.0.0.1:8091/v1
# Provide API key for restricted-email shares
fastfold agent fork <share_id> --fastfold-api-key sk-...
# Import chat only (skip files)
fastfold agent fork <share_id> --no-filesBehavior:
- Public-link shares work without an API key.
- Restricted-email shares require a valid
FASTFOLD_API_KEYfrom an allowed account. - Imported files are restored under:
<sandbox.output_dir>/shared_forks/<share_id>/...
- The command prints a resume hint:
fastfold --resume <session_id>
Inside fastfold interactive mode (run /help for the full reference):
Discover
/help: show command reference with examples/tools: list all tools with status (stable/experimental)/data: manage local datasets (/data list,/data status,/data pull <name>,/data pull-all)/skills: list currently loaded skills/skills-find [query]: discover installable skills from the catalog/skills-add <source>: install a skill from GitHub/local path/name/skills-remove <name>: remove a globally-installed skill/case-study: run/list curated case studies (/case-study list)
Models & configuration
/model: switch LLM model/provider interactively/model-manager: manage OpenAI-compatible profiles (add/edit/delete + diagnostics)/settings: configure UI and agent preferences/config: show active runtime configuration/keys: show API key setup status by service (/keys profile,/keys set-compatible <profile_id>,/keys set-boltz)
Run control
/agents N <query>: run a query with N parallel research agents/plan: toggle plan mode (preview & approve before executing)/interrupt: interrupt the active generation (add!to force)/compact: compress session context for longer runs/tasks: show background task watcher status (/tasks refreshfor live probe)
Sessions & output
/new: start a new empty session/sessions: list saved sessions (or delete:/sessions delete <id>)/resume: resume a previous session by id/index/usage: show session token/cost usage/copy: copy the last answer to clipboard/export: export current session transcript to markdown/export-share: export session, send to Slack, and save to library/notebook: export current session as Jupyter notebook (.ipynb)
Maintenance
/upgrade: upgradefastfold-agent-clivia uv/doctor: run readiness diagnostics and fix hints/clear: clear the screen/exit: exit the terminal
Target prioritization
fastfold "I have a CRBN molecular glue. Proteomics shows it degrades
IKZF1, GSPT1, and CK1α. Which target should I prioritize?"
Protein folding
fastfold "Fold this sequence with boltz-2 and find the binding pockets: MALWMRLLPLL..."
Combination strategy
fastfold "My lead compound is immune-cold. What combination strategy should I use?"
| Category | Examples |
|---|---|
| Target | Neosubstrate scoring, degron prediction, co-essentiality networks |
| Chemistry | SAR analysis, fingerprint similarity, scaffold clustering |
| Expression | L1000 signatures, pathway enrichment, TF activity, immune scoring |
| Viability | Dose-response modeling, PRISM screening, therapeutic windows |
| Biomarker | Mutation sensitivity, resistance profiling, dependency validation |
| Clinical | Indication mapping, population sizing, TCGA stratification |
| Safety | Anti-target flagging, multi-modal profiling, SALL4 risk |
| Structure | AlphaFold fetch, docking, binding sites, MD simulation |
| Folding | Fastfold AI Cloud: boltz-2, monomer, multimer, simplefold_* |
| Literature | PubMed, OpenAlex, ChEMBL search |
| DNA | ORF finding, codon optimization, primer design, Gibson/Golden Gate assembly |
The agent runs on a Deep Agents (LangGraph) runtime with native progressive skill discovery, so skill details load on demand and you can install many skills without bloating the prompt. Anthropic prompt caching is enabled automatically, and the footer shows fresh (non-cached) input tokens so the numbers stay meaningful.
Programmatic Tool Calling (PTC) is the default tool mode (agent.tool_mode=ptc): the agent calls domain tools as Python functions inside a persistent sandbox and discovers them through a compact catalog plus search_tools, instead of injecting every tool's JSON schema. This significantly reduces per-turn input tokens and removes the OpenAI tool-count ceiling. Set agent.tool_mode=native to restore per-tool schemas.
Tool-call traces keep the current/last call in full detail and progressively collapse older ones to compact named lines (tune with agent.tool_trace_detail_limit; set agent.group_tool_traces=false for fully verbose output).
Fastfold ships with a bundled skill catalog and lets you discover, add, and manage skills natively. Installed skills live in ~/.fastfold-cli/skills/ and are picked up automatically.
List what's loaded:
fastfold skills listDiscover skills from the catalog:
fastfold skills find # browse all
fastfold skills find "protein design" # filter by queryAdd a skill from a GitHub URL, owner/repo@subpath, a local path, or a catalog name:
fastfold skills add https://github.com/fastfold-ai/skills/tree/main/skills/fold
fastfold skills add fastfold-ai/skills@skills/fold
fastfold add skills ./my-skill # alias for `skills add`Keep skills current (sync the Fastfold catalog — adds new + updates existing — and re-install other tracked skills):
fastfold skills upgrade # sync catalog + update installed
fastfold skills upgrade --catalog-only # only refresh the Fastfold catalog
fastfold skills upgrade --no-catalog # only update already-installed skillsInspect or remove:
fastfold skills info fold
fastfold skills remove fold
fastfold skills delete --all # remove ALL user-installed skills (asks to confirm)Inside the interactive session you can use the slash commands /skills, /skills-find [query], /skills-add <source>, and /skills-remove <name>. Install uses a native git clone and falls back to npx skills add (skills.sh) when needed.
fastfold setup also offers to install skills interactively — it live-fetches the current Fastfold catalog, lets you multi-select, suggests the community collections below, and accepts custom sources. It prefers npx skills add when Node is available, otherwise uses git. Non-interactive: fastfold setup --skills "fastfold-ai/skills@skills/fold,..." or --skip-skills.
You can also install skills from other providers. Each command installs the whole collection (use npx skills add ... instead if you prefer Node):
- K-Dense-AI — scientific agent skills (repo)
fastfold skills add K-Dense-AI/scientific-agent-skills- Anthropic — life-sciences skills (repo)
fastfold skills add anthropics/life-sciences- DeepMind — science skills (repo)
fastfold skills add google-deepmind/science-skillsCreate your own skill with the bundled skill-creator (scaffold, validate, package), and let the agent discover skills via the find-skills skill. To let the agent install skills itself, enable fastfold config set skills.allow_agent_install true.
fastfold data list # catalog: description, size, auto/manual
fastfold data status # what's downloaded locally
fastfold data pull depmap # DepMap CRISPR, mutations, expression
fastfold data pull prism # PRISM cell viability
fastfold data pull msigdb # Gene sets
fastfold data pull alphafold # Protein structures (on-demand)
fastfold data pull-all # every auto-downloadable dataset (depmap is ~580MB)
# Or point to existing data
fastfold config set data.depmap /path/to/depmap/fastfold setup also offers an optional dataset step with a multi-select (all
auto-downloadable datasets preselected). Non-interactive:
fastfold setup --datasets depmap,msigdb (or --datasets all / --skip-datasets).
The same actions are available inside the interactive session via /data
(/data list, /data status, /data pull <name>, /data pull-all).
fastfold report list # list reports
fastfold report publish # convert latest .md to .html
fastfold report show # open in browserBrowse the Fastfold Apps catalog at https://cloud.fastfold.ai/apps
- Fold model options include: ESM-1b, IntelliFold, OpenFold 3, AlphaFold2, Boltz-1, Boltz-2, Chai-1, and SimpleFold.
- MD workflow options include: OpenMM Calvados and OpenMMDL.
- Protein Design workflows coming soon: Boltzgen and Bindcraft.
Coming soon. Generic Q&A leaderboards don't capture what matters here, so we're crafting a comprehensive benchmark focused on industry-specific drug-discovery and computational-biology use cases: the multi-step, tool-heavy workflows scientists actually run (target prioritization, folding, protein design, MD, omics analysis, and more), measured across multiple model backends.
We are looking for help. If you have a real-world use case you'd like represented, or want to contribute tasks, datasets, or scoring rubrics, please open an issue or say hi on Slack. The goal is an honest, reproducible measure of how the agent performs across many domains.
Contributions are welcome, from bug reports and docs fixes to new tools and skills.
Clone the repo and set up a development environment:
git clone https://github.com/fastfold-ai/fastfold-agent-cli.git
cd fastfold-agent-cli
uv venv --python 3.12 && uv sync
fastfold setupRun the test suite before opening a PR:
pytest tests/ # full suite
pytest tests/ -v # verbose
pytest tests/test_cli.py::test_name # a single testAdding a new tool? Tools live in src/tools/ and register with the @registry.register(...) decorator. Each tool's name prefix must match its category, it should accept **kwargs, and it must return a dict with a "summary" key. Use lazy imports for data loaders inside the function body. See CLAUDE.md for the full tool pattern and conventions.
A few guidelines:
- Keep changes focused and add tests for new behavior (tests mock data loaders, so they don't require real datasets).
- Match the existing code style and run
pytestlocally until green. - Open a PR with a clear description of the change and why it's needed.
MIT
Fastfold Agent CLI stands on the shoulders of excellent open-source work:
- CellType: most of the 190+ domain tools and prompt definitions are derived from or inspired by CellType's open-source computational-biology agent, which reports a state-of-the-art 90% on BixBench-Verified-50.
- BixBench and the BixBench-Verified-50 dataset: the evaluation that grounds the domain-agent results above.
- Deep Agents (LangChain / LangGraph): the agentic runtime Fastfold is built on today, providing progressive skill discovery and the foundation for Programmatic Tool Calling.
- open-ptc-agent: the reference that shaped Fastfold's Programmatic Tool Calling (PTC) approach to keeping per-turn tokens low.