awesome-research-agents

# Awesome Research Agents 2026 [](https://awesome.re) > An opinionated, curated list of agents, skills, MCP servers, and tools > that ML researchers actually use, not another 340-item link-dump. Last reviewed 2026-05-13. 44 entries. The existing "awesome AI agents 2026" repos are catalogs of every tool that exists. Catalogs are useful exactly once, when you don't know a space exists. After that you want judgment: which of these is actually maintained, which is a thin wrapper, which is paid-only with a useless free tier, and which is the one you'd recommend to your labmate at 11pm before a deadline. This is that list. Every entry is something I've either used in real work or have seen at least two trustworthy researchers vouch for. Every entry has a "Why we recommend it" paragraph that says something the project's own README will not. Every entry has a one-line "When not to use", because setting expectations is the entire point of curation. The taxonomy is by research workflow stage (discover, read, experiment, code, evaluate, write, share, stay current) rather than by tech type. A junior researcher knows what they're trying to do; they don't know whether the tool that does it is "an agent framework" or "an MCP server". Entries are re-verified quarterly. If a tool stops being maintained, it gets cut. If a better alternative appears, it gets replaced. PRs welcome, the bar is high. See [CONTRIBUTING.md](CONTRIBUTING.md). ## Contents - [Discover & Explore](#discover--explore) - [Read & Annotate](#read--annotate) - [Experiment & Track](#experiment--track) - [Code & Build](#code--build) - [Evaluate & Benchmark](#evaluate--benchmark) - [Write & Submit](#write--submit) - [Share & Replicate](#share--replicate) - [Stay Current](#stay-current) - [Not (yet) recommended](#not-yet-recommended) - [Contributing](#contributing) - [License](#license) ## Discover & Explore Finding, surfacing, and querying the literature. Bar: does it cut a real research hour, or is it a fancy abstract summarizer? - **[Elicit](https://elicit.com)** — *AI-powered structured literature review.* `closed-source` · `free-tier` · `checked-2026-05` - Why we recommend it: of the closed-source paper-search products, Elicit is the one where the per-paper claim tables save enough time on systematic reviews to justify the workflow lock-in. The free tier is real, you can run meaningful reviews without paying. The retrieval is closed and we can't audit it. - When not to use: domain reviews where Semantic Scholar's filters already do the job, or where reproducibility of the search matters (Elicit can't be queried programmatically with a stable seed). - **[AI2 Scholar QA](https://github.com/allenai/ai2-scholarqa-lib)** — *Open evidence-grounded literature synthesis.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: AI2's productization of the OpenScholar work, with a corpus of 11M+ full-text and 100M+ abstracts and per-claim citations. Worth running locally if you care about ground-truth attribution; every claim links to its source paper. The original [`AkariAsai/OpenScholar`](https://github.com/AkariAsai/OpenScholar) is the research artifact, this is the maintained library. - When not to use: quick exploratory queries where Elicit's polish is worth the closed-source trade. Self-hosting AI2 Scholar QA is non-trivial. - **[arxiv-mcp-server](https://github.com/blazickjp/arxiv-mcp-server)** — *Search and fetch arXiv from any agent.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the canonical arXiv MCP. Once installed, Claude or Cursor or any MCP client can run arXiv queries inline: drop a paper title in chat, get the abstract back. Small, focused, the right shape for an MCP server. - When not to use: when you need citation graphs or impact metrics. arXiv has neither. Pair with the Semantic Scholar MCP below for that. - **[semantic-scholar-fastmcp-mcp-server](https://github.com/zongmin-yu/semantic-scholar-fastmcp-mcp-server)** — *225M-paper search + citation graphs over MCP.* `open-source` · `free-tier` · `checked-2026-05` - Why we recommend it: the cleanest of the half-dozen Semantic Scholar MCPs we tested. FastMCP-based, comprehensive coverage of the S2 API (papers, authors, citations, references). Semantic Scholar's free API has rate limits; for heavy use you'll want an API key. - When not to use: if you only need paper retrieval, the arXiv MCP is simpler and faster. - **[hf-mcp-server](https://github.com/huggingface/hf-mcp-server)** — *Official Hugging Face Hub MCP server.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: official, hosted at `huggingface.co/mcp`, and the easiest way to give an agent live access to models, datasets, papers, and Spaces. The hosted version is fine for most users; self-host only if you need stricter network isolation. Seven built-in tools plus arbitrary Gradio Spaces. - When not to use: if you only need daily-papers, the lighter [`huangxinping/huggingface-daily-paper-mcp`](https://github.com/huangxinping/huggingface-daily-paper-mcp) is more surgical. ## Read & Annotate The tools between "PDF downloaded" and "notes in Zotero". - **[Zotero](https://www.zotero.org)** — *Open reference manager and PDF annotator.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: twenty years of compounding goodwill, an open data format, a real plugin ecosystem, and the only reference manager you can fully script. Free, no AI bloat, non-profit org. Desktop UI is dated and the cloud-sync free tier is small (paid storage starts at $20/yr). - When not to use: if you live in your browser and never touch LaTeX, the lighter web-only tools (Readwise Reader, Paperpile) feel snappier, but they lock your data. - **[Better BibTeX](https://retorque.re/zotero-better-bibtex/)** — *Zotero plugin for sane BibTeX workflows.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: if you use Zotero with LaTeX, this is non-optional. Stable citekeys, live `.bib` export, JSON-RPC endpoint other tools can hit. Mention this any time a colleague complains about citation keys changing on them. - When not to use: pure Typst or Word workflows. Even there, Better BibTeX's CSL JSON export is useful. - **[Marker](https://github.com/VikParuchuri/marker)** — *PDF to clean Markdown with structure preserved.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: best-of-class PDF-to-Markdown for academic papers as of mid-2026. Handles equations, tables, and reference lists better than the alternatives, and runs locally on a single GPU. Pipeline (layout, OCR, reading-order, table-format) is open and auditable. - When not to use: born-digital PDFs with clean structure. `pdftotext` is enough and 100x faster. Marker shines on scanned or layout-heavy docs. - **[GROBID](https://github.com/kermitt2/grobid)** — *Citation and structure extraction from academic PDFs.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the thing every paper-indexing pipeline secretly runs under the hood. If you want structured XML (TEI) of a paper, GROBID is the only serious open option. Java, batch-oriented, not pretty, but indispensable for any home-grown lit-search system. - When not to use: if you only want Markdown for human reading, Marker is friendlier. GROBID is for pipelines. - **[Nougat](https://github.com/facebookresearch/nougat)** — *Neural PDF parser tuned for scientific docs.* `open-source` · `free` · `checked-2026-05` · `[needs-verify]` - Why we recommend it: Meta's scientific-PDF model is particularly strong on equation-heavy ML papers. Listed as a Marker alternative for math-dense reading. Meta has slowed updates noticeably in 2026, so quality won't keep pace with frontier models indefinitely. - When not to use: new PDFs from 2025+. Marker has caught up and is actively maintained. Reach for Nougat mainly for archived dense-math literature. ## Experiment & Track Tracking experiments, getting GPUs, and not losing your mind when a run dies overnight. - **[Weights & Biases](https://wandb.ai)** — *Hosted experiment tracking with a real free tier.* `closed-source` · `free-tier` · `checked-2026-05` - Why we recommend it: the default for solo researchers and small teams. Free tier covers a single researcher indefinitely, the visualization quality is unmatched, and the [official `wandb-mcp-server`](https://github.com/wandb/wandb-mcp-server) lets an agent query your runs and Weave traces inline. Closed product, your data lives on W&B's servers, enterprise upsell is real. - When not to use: sensitive data (regulated industry, security research), use MLflow self-hosted. Heavy multi-team RBAC, also MLflow or a paid plan. - **[MLflow](https://mlflow.org)** — *Fully open self-hostable tracking + model registry.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the serious-org choice. Self-hostable, audit trail, model registry, project format, mature integration ecosystem. UI less polished than W&B but the only one you can run completely air-gapped. - When not to use: solo researcher with no infra. The W&B free tier saves you a docker-compose file and a PostgreSQL instance. - **[Aim](https://github.com/aimhubio/aim)** — *Lightweight open experiment tracker.* `open-source` · `free` · `checked-2026-05` · `[needs-verify]` - Why we recommend it: the middle ground between "SQLite and a notebook" and "spin up MLflow". Pip-install, local-first, decent UI, honest abstraction (Aim doesn't pretend to be a deployment platform). Good for a single project where MLflow is overkill. - When not to use: cross-project comparison or team workflows. Aim's single-project focus shows. - **[Modal](https://modal.com)** — *Serverless compute with an honest free tier.* `closed-source` · `free-tier` · `checked-2026-05` - Why we recommend it: decorate a Python function and it runs on remote GPUs. The free tier ($30/mo of credit at last check) is enough for a researcher's "I just need to run this 4-hour experiment" needs. Mental model "Modal is your laptop, but bigger" is genuinely better than the SkyPilot/Slurm equivalents for small teams. - When not to use: long-running multi-week training. The pricing math doesn't work past a certain scale; at that point you want SkyPilot on raw cloud VMs. - **[SkyPilot](https://github.com/skypilot-org/skypilot)** — *Run any job on any cloud, pick the cheapest GPU.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: from UC Berkeley, the right abstraction for "I need a GPU, I don't care which cloud, just find me the cheapest spot." Manages spot-instance preemption, multi-cloud failover, and is the only tool in this category we'd recommend to a grad student with research credits on three providers. Setup is a real afternoon. - When not to use: one-off tiny jobs (use Modal). Pure on-prem clusters (use Slurm, the boring answer is the right answer). - **[PyTorch Lightning](https://lightning.ai)** — *Boilerplate-free PyTorch training loops.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the least-objectionable training-loop framework. Strips the for-loop boilerplate without burying you in abstraction; pairs cleanly with W&B and MLflow. Lightning Fabric is the looser variant if `LightningModule`'s structure annoys you. The org has shifted focus toward `lightning.ai` (commercial), but the OSS core remains community-maintained. - When not to use: research code where the training loop *is* the contribution (e.g., novel optimizer dynamics). Write raw PyTorch. ## Code & Build Coding agents, agent frameworks, and skill bundles. Section cap is real; the ones below are the ones I actually use. - **[Claude Code](https://claude.com/claude-code)** — *Anthropic's terminal-native coding agent.* `closed-source` · `paid` · `checked-2026-05` - Why we recommend it: the reason this list's audience exists. Best at codebases of moderate size, terminal-native, and the Skills system means it composes with everything else on this list. Closed model, requires API budget. For ML researchers, the productivity delta is the most measurable on this list. - When not to use: strict cost ceilings or fully-local-inference requirements, use Aider with a local model. Codebases that need multi-hour autonomous loops, pair with OpenHands. - **[Aider](https://aider.chat)** — *Open, model-agnostic terminal coding agent.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the reference open implementation. Model-agnostic (Claude, GPT, local), git-integrated, fast, the maintainer ships features faster than most VC-funded competitors. Aider's repo-map heuristic is genuinely novel and worth reading the source. - When not to use: long-horizon autonomous loops. Aider is interactive by design. - **[Cline](https://github.com/cline/cline)** — *Open VS Code coding agent.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: if you live in VS Code, Cline is the open answer to closed editors. Model-agnostic, MCP-aware, autonomous mode is real (not marketing). The recent fork ecosystem (Roo Code and friends) is a sign of healthy community activity, not fragmentation. - When not to use: terminal-first workflows. Use Aider or Claude Code. - **[OpenHands](https://github.com/All-Hands-AI/OpenHands)** — *Open autonomous coding agent (formerly OpenDevin).* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the serious open answer to autonomous-agent claims. Sandboxed execution, real benchmarking on SWE-bench, and the rename from OpenDevin signals a maturity shift away from the early hype cycle. Worth running for tasks where the agent needs to operate for an hour without supervision. - When not to use: interactive pair-programming. OpenHands' overhead per turn is wrong for that. - **[LangGraph](https://github.com/langchain-ai/langgraph)** — *State-machine agent orchestration for Python.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: of the agent frameworks, LangGraph is the one whose abstraction (typed state, explicit graph edges, checkpointing) maps cleanly to how researchers actually want to build custom agent loops. Skip the LangChain layer above it if it annoys you; LangGraph stands on its own. Picked over CrewAI because CrewAI's "role-playing" framing optimizes for demos, not for research code. - When not to use: single-turn LLM calls. Just call the SDK directly; frameworks tax simple problems. - **[DSPy](https://github.com/stanfordnlp/dspy)** — *Programming, not prompting, LM pipelines.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: Stanford's optimization-first framing of prompt engineering. You declare signatures and let DSPy compile/tune the prompts against a metric. The research lineage is real and the framework has become a quiet standard in NLP labs. Steeper learning curve than "just write a prompt"; payoff is reproducibility. - When not to use: quick prototypes. DSPy's compile-time machinery is overkill until you have a real eval set. - **[smolagents](https://github.com/huggingface/smolagents)** — *Tiny, hackable agent framework from Hugging Face.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the framework you can read end-to-end in an afternoon. Hugging Face's reaction against the LangChain/CrewAI complexity, and the better choice for a research project that needs to *modify* the agent loop rather than configure it. Code-as-actions (the agent emits Python, not JSON tool calls) is the right design for many agentic-research papers. - When not to use: production systems where you want guardrails. smolagents' "execute Python" approach has obvious safety implications. - **[Anthropic Skills](https://github.com/anthropics/skills)** — *Reference skills library for Claude Code.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the canonical examples of what a `SKILL.md` looks like. Worth reading even if you use a different agent runtime. The YAML-frontmatter-plus-markdown pattern has become a de facto interchange format across Claude Code, Codex, Gemini CLI, and Cursor. - When not to use: one-shot tasks. Just write a prompt. Skills earn their weight on repeated workflows. ## Evaluate & Benchmark How you know your agent or model is actually better, not just newer. - **[Inspect AI](https://github.com/UKGovernmentBEIS/inspect_ai)** — *UK AISI's evaluation framework for LLMs and agents.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the framework with the cleanest abstraction for agent evaluation specifically. Solvers, scorers, sandboxes, and a real sandboxed-execution story. Maintained by UK AISI, which means the threat model is serious and the API doesn't change for marketing reasons. - When not to use: pure-text LLM benchmarking with thousands of multiple-choice items. `lm-evaluation-harness` is the more direct tool. - **[lm-evaluation-harness](https://github.com/EleutherAI/lm-evaluation-harness)** — *EleutherAI's canonical LLM benchmark runner.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the de facto standard. If your paper claims a number on MMLU, GSM8K, HumanEval, etc., reviewers expect you to have run lm-eval-harness, full stop. Huge task registry, stable API, fast bug-fix cycle. - When not to use: agentic / multi-turn evaluations, use Inspect AI. Anything that needs sandboxed code execution at scale, also Inspect AI. - **[HELM](https://github.com/stanford-crfm/helm)** — *Stanford CRFM's holistic LLM evaluation framework.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: heavier setup than lm-eval-harness, but HELM's commitment to holistic dimensions (calibration, robustness, bias, efficiency) makes it the better choice when you're publishing in a venue that cares about more than top-line accuracy. The Stanford team treats it as a research artifact, not a product; has both depth strengths and slow-to-adopt-new-models weaknesses. - When not to use: quick numbers for a paper, setup tax is real. Most agentic evals, HELM was designed pre-agent. - **[Promptfoo](https://github.com/promptfoo/promptfoo)** — *Test-driven prompt evaluation, eng-flavored.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the framework when you want eval-as-CI. Declarative YAML test cases, model comparisons across providers, and a workflow that feels like `pytest` instead of `python evaluate.py`. Eng-y, but that's the point; it survives a transfer to a coworker. - When not to use: academic benchmark replication. Promptfoo's strengths are workflow, not standardized coverage. - **[OpenAI Evals](https://github.com/openai/evals)** — *OpenAI's eval framework + benchmark registry.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: still maintained in 2026. The registry is the real value, historical benchmarks contributed by the community. Confusingly, OpenAI also publishes [`openai/simple-evals`](https://github.com/openai/simple-evals) which they explicitly do not maintain; make sure you use the right one. - When not to use: anything that needs to run on non-OpenAI models without adapter friction. Inspect AI or lm-eval-harness are more provider-neutral. ## Write & Submit LaTeX, alternatives, and submission infra. - **[Overleaf](https://www.overleaf.com)** — *Collaborative LaTeX editor with a real free tier.* `closed-source` · `free-tier` · `checked-2026-05` - Why we recommend it: the free tier (one collaborator, 60-min compile timeout) is enough for almost every solo paper, the Git integration on paid tiers is solid, and the export-to-anywhere story (download `.zip`, push to arXiv) means you're never locked in. Paid plans for multi-author teams add up; consider self-hosting Overleaf CE if budget is real. - When not to use: solo-author papers where you'd rather use VS Code + LaTeX Workshop locally. Privacy-sensitive content, Overleaf's free tier sees your draft. - **[LaTeX Workshop](https://github.com/James-Yu/LaTeX-Workshop)** — *The VS Code LaTeX extension worth using.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: pair this with a local TeX Live and you have a faster, version-controllable, agent-compatible writing environment than Overleaf, for the cost of one afternoon of setup. SyncTeX works, lint is decent, no compile timeout. - When not to use: real-time multi-author collaboration. Overleaf still wins there. - **[Typst](https://typst.app)** — *Modern typesetting; faster than LaTeX, with sane syntax.* `open-source` · `free-tier` · `checked-2026-05` - Why we recommend it: a real attempt to replace LaTeX, and after two years of adoption it's earned a place. Fast compile, readable error messages, package ecosystem that's no longer embarrassing. Many conferences still require LaTeX (NeurIPS, ICML), so Typst is for blog posts, theses, and journals that accept it. - When not to use: conferences with mandatory LaTeX style files. Conversion friction is real. - **[Quarto](https://quarto.org)** — *Scientific publishing built on Pandoc; R/Python/Julia.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the successor to R Markdown and now a serious option for reproducible scientific writing across Python, R, and Julia. Notebook-ish source, multiple output formats (PDF, HTML, EPUB), grown-up cross-reference and citation handling. Pairs naturally with Jupyter / VS Code. - When not to use: equation-heavy ML conference papers. You'll fight the engine; use LaTeX or Typst. - **[OpenReview](https://openreview.net)** — *Submission and reviewing infrastructure for ML conferences.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: listed because new researchers underestimate the workflow. OpenReview is the submission, review, and rebuttal surface for ICLR, NeurIPS, COLM, TMLR, and most ML venues. The [official Python API client](https://github.com/openreview/openreview-py) lets you script bulk operations, useful for area chairs and reproducible meta-analyses. - When not to use: submission portals that don't use it (CVPR uses its own; ACL uses an ARR-flavored OpenReview). Check before you write the submission script. ## Share & Replicate Once it works, how do you make it reproducible? - **[Hugging Face Hub](https://huggingface.co)** — *The de facto home for open models, datasets, and demos.* `closed-source` · `free` · `checked-2026-05` - Why we recommend it: free model and dataset hosting with no real size cap, Spaces for demos, version control via git-lfs. The default place to put a research artifact in 2026, and the network effects compound. HF the company is a vendor, the platform is not federated, the storage model is theirs. - When not to use: long-term archival for funding-body compliance. Use Zenodo (DOI'd, mirrored, library-grade). - **[Hugging Face Datasets](https://github.com/huggingface/datasets)** — *Python library for streaming and processing datasets.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: distinct from the Hub; a library you `pip install` and call. Streaming, memory-mapping, Arrow-backed, lazy operations. The right primitive for "this dataset is larger than my RAM but I want to iterate." Worth using even with non-HF data sources. - When not to use: single in-memory NumPy arrays. `datasets` is overkill. - **[Zenodo](https://zenodo.org)** — *CERN-hosted research artifact repository with DOIs.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: when a paper says "data and code available at Zenodo," that's the right answer. CERN-hosted, library-grade preservation, DOI minting, GitHub integration that creates a Zenodo release on every GitHub release. Funding bodies (NSF, ERC) accept Zenodo as compliant archival storage. - When not to use: active development. Use GitHub or HF. Zenodo is for the final artifact. - **[Dev Containers](https://containers.dev)** — *Open spec for reproducible dev environments.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: a `.devcontainer/devcontainer.json` makes your repo one-click-reproducible in VS Code, GitHub Codespaces, JetBrains IDEs, and increasingly other tools. The right minimal commitment for "I want a future reviewer to be able to run this code." Lighter weight than a full Docker tutorial in your README. - When not to use: pure-data research with no real software install. A `requirements.txt` is enough. ## Stay Current Newsletters, deadline trackers, signal-rich channels. - **[agent-deadlines](https://github.com/REPLACE-ME/agent-deadlines)** *(by the curator)* — *AI conference deadlines as a CLI / MCP / Skill.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: companion to this list. Where Hugging Face's ai-deadlines (entry below) gives you a website, `agent-deadlines` gives you the same data as a CLI (`agent-deadlines next 5`), an MCP server, and a Claude Code Skill that surfaces upcoming deadlines proactively in research conversations. Hand-curated, 29 conferences, CC0 data. - When not to use: if a website is what you want, use HF's fork below; we don't compete with it. - **[Hugging Face's ai-deadlines](https://github.com/huggingface/ai-deadlines)** — *Maintained successor to aideadlin.es.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: the website surface. The original `aideadlin.es` is no longer maintained, and HF's fork has become the de facto active replacement (561+ commits, agent-based auto-update). If you just want "what's coming up" on a webpage, this is it. `agent-deadlines` co-exists with this; we curate independently. - When not to use: terminal or agent workflows. `agent-deadlines` is shaped for those. - **[ccfddl.com](https://ccfddl.com)** — *China Computer Federation conference deadline tracker.* `open-source` · `free` · `checked-2026-05` - Why we recommend it: maintained, comprehensive, the China-CS community uses it as canonical. The CCF ranking labels (A/B/C) are useful as a sanity check even if you don't fully buy the methodology. Covers many systems/theory venues that ML-only trackers skip. - When not to use: if you're already on HF's tracker. Venue overlap is large. - **[Import AI](https://importai.substack.com)** — *Jack Clark's weekly AI policy and research digest.* `closed-source` · `free` · `checked-2026-05` - Why we recommend it: longest-running serious AI newsletter (since 2017), one of the few that surfaces policy-adjacent material researchers should know about, and Clark's editorial taste is the closest thing to ground truth on "what mattered this week." Format (research roundup + tech tales) is a known quantity. - When not to use: real-time news. Clark publishes weekly. For minute-by-minute, use Twitter. - **[Interconnects](https://www.interconnects.ai)** — *Nathan Lambert's research-focused newsletter.* `closed-source` · `free-tier` · `checked-2026-05` - Why we recommend it: Lambert (AI2, formerly HF) writes the post-training and RLHF coverage that actually maps to how labs work. Free tier is real and meaningful (most posts free), paid adds detail but isn't required. Best read after Import AI for depth on a specific topic. - When not to use: pure infra or systems work. Interconnects is model-focused. - **[Latent Space](https://www.latent.space)** — *swyx's newsletter and podcast on agents and AI engineering.* `closed-source` · `free-tier` · `checked-2026-05` - Why we recommend it: the publication for the agent / MCP / coding-agent corner of the ecosystem. Conference recaps are high-signal, podcast guest list is who's-actually-shipping, and swyx's editorial framing ("AI engineering" as a discipline) has become the standard vocabulary. - When not to use: pure ML research (training, theory). Latent Space is engineering-and-product flavored. ## Not (yet) recommended Tools evaluated and not included. Listed here so readers don't think I missed them. - [Cursor](https://cursor.com): closed editor, real product but locked into a single vendor's runtime and pricing has crept up. Same workflow defensible with Claude Code + Aider + Cline and an open editor. Reconsider if pricing and openness change. - [Undermind](https://www.undermind.ai): genuinely strong agentic lit-search, but the free tier (2 searches/month at last check) is too thin to recommend as a default. Worth trying if you have budget. - [LangSmith](https://smith.langchain.com): paid-only with no real free tier for serious research use. The OSS alternatives in Evaluate & Benchmark cover the same ground. - [Paperpile](https://paperpile.com): paid-only reference manager. Zotero covers the same ground openly and scriptably. - [CrewAI](https://github.com/crewAIInc/crewAI): real project, but "role-playing agents" framing optimizes for demos. For research code I prefer LangGraph's typed-state explicit-edges abstraction. Reconsider if CrewAI lands a clear research-flow advantage. ## Contributing Contributions welcome. Read [CONTRIBUTING.md](CONTRIBUTING.md) first. The bar is high: any suggested addition must come with a paragraph defending its inclusion against the alternatives in the same section, and self-promoters must disclose. ## License [](https://creativecommons.org/publicdomain/zero/1.0/)