Key takeaways
- The de facto standard for symbol-level agent tooling: 25.2K GitHub stars, 1.6K forks, and 170+ contributors as of June 2026 — making it a pre-existing omission from this category rather than a new entrant
- Architecture is LSP-over-MCP: language servers power semantic tools like find_symbol, find_referencing_symbols, and replace_symbol_body, so agents navigate and edit code by symbol instead of line numbers or grep
- Works with essentially every major agent surface — Claude Code, Codex, OpenCode, Gemini CLI, Cursor, VS Code Copilot, JetBrains assistants, Claude Desktop — across 40+ programming languages
- Free MIT-licensed core with a paid JetBrains plugin as the first monetization step; no disclosed funding, maintained by Munich-based Oraios AI
FAQ
What is Serena?
Serena is an open-source MCP server that gives AI coding agents semantic, symbol-level code retrieval, editing, and refactoring tools backed by language servers — "the IDE for your coding agent."
How much does Serena cost?
The core toolkit is free and MIT-licensed; a paid Serena JetBrains Plugin (with a free trial) is the only commercial offering as of June 2026.
Which coding agents does Serena work with?
Any MCP client — documented integrations include Claude Code, Codex, OpenCode, Gemini CLI, Cursor, VS Code Copilot, JetBrains AI Assistant and Junie, Claude Desktop, and OpenWebUI.
How is Serena different from Octocode MCP?
Both expose LSP navigation over MCP, but Serena is primarily a local symbol-level editing and refactoring toolkit (rename, move, inline, replace_symbol_body), while Octocode MCP centers on research across GitHub repos, PR history, and package discovery.
Executive Summary
Serena bills itself as "the IDE for your coding agent": an open-source MCP server that wraps language servers and exposes their semantic understanding — symbols, references, type hierarchies, diagnostics — as agent tools, so a coding agent can navigate and edit a codebase the way an IDE user does rather than by grepping text and counting line numbers.[1] Retrieval tools (find_symbol, symbol_overview, find_referencing_symbols, type_hierarchy), symbolic editing tools (replace_symbol_body, insert_after_symbol, safe_delete), and refactoring operations (rename, move, inline) work across 40+ programming languages via the LSP backend.[1]
One honesty note on this profile's timing: Serena is not a new entrant. The repository was created in March 2025 and had accumulated 25.2K stars, 1.6K forks, and 170+ contributors by June 2026 — it is the most-starred tool in this category's open-source tier, and its absence from earlier versions of this comparison was an omission, not a reflection of its standing.[1] Maintainer Oraios AI ships steadily: v1.5.3 landed May 26, 2026, and the repo was pushed again on June 11, 2026.[2][1]
| Attribute | Value |
|---|---|
| Creator | Oraios AI (with Oraios Software)[3] |
| Established | March 2025 (repo created March 23, 2025)[1] |
| Funding | Not publicly disclosed |
| GitHub Stars | 25.2K (1,688 forks, 170+ contributors) as of June 2026[1] |
| License | MIT; core free, paid JetBrains plugin[1] |
| Language | Python[1] |
Product Overview
Serena's premise is that agents fail less when they stop treating code as text. Instead of low-level primitives like line numbers and search patterns, its "agent-first tool design" gives the model high-level abstractions: find a symbol by name, list everything that references it, replace its body atomically, rename it project-wide.[1] The README's framing of the payoff: cross-file renames "collapse into one atomic call" versus "8–12 careful, error-prone steps" with text-based tools.[1]
On first use Serena onboards a project — reading files and writing summary notes to .serena/memories that persist across sessions — then serves tools over MCP to whatever client connects.[4][3] A local dashboard/GUI tool provides visibility into what the server is doing.[3]
Key Capabilities
| Capability | Description |
|---|---|
| Semantic retrieval | find_symbol, symbol_overview, find_referencing_symbols, type_hierarchy, diagnostics[1] |
| Symbolic editing | replace_symbol_body, insert_after_symbol, insert_before_symbol, safe_delete[1] |
| Refactoring | Rename, move, inline, propagate_deletions[1] |
| Text fallbacks | search_for_pattern, replace_content, read_file, execute_shell_command[1] |
| Memories & onboarding | Project summaries persisted to .serena/memories for cross-session context[3][4] |
| Dashboard | Local GUI for observing server activity[3] |
Product Surfaces
| Surface | Description | Availability |
|---|---|---|
| MCP server | Core toolkit for any MCP client | Free, MIT[1] |
| Terminal agents | Claude Code, Codex, OpenCode, Gemini CLI | Documented integrations[1] |
| IDE assistants | VS Code/Cursor (Copilot), JetBrains (Junie, AI Assistant) | Documented integrations[1] |
| Desktop/web | Claude Desktop, Codex App, OpenWebUI | Documented integrations[1] |
| JetBrains plugin | Enhanced in-IDE experience | Paid, free trial[1][3] |
Technical Architecture
Serena is a Python application that runs locally, spawning and managing language servers per project and translating LSP capabilities into MCP tools — no cloud component, no embeddings index, no code leaves the machine beyond what the connected agent itself sends to its model.[1] Installation is via uv (uv tool install -p 3.13 serena-agent, then serena init); the README explicitly warns "Do not install Serena via an MCP or plugin marketplace!" because marketplaces carry outdated install commands.[1]
Key Technical Details
| Aspect | Detail |
|---|---|
| Deployment | Local-only Python process; language servers managed per project[1] |
| Model(s) | Model-agnostic — serves tools to whatever agent connects over MCP[1] |
| Integrations | Claude Code, Codex, OpenCode, Gemini CLI, Cursor, VS Code, JetBrains, Claude Desktop, OpenWebUI[1] |
| Languages | 40+ via LSP, incl. Python, TypeScript, Java, Go, Rust, C/C++, C#, Ruby, PHP, Kotlin[1] |
| Open Source | MIT core; paid JetBrains plugin is the proprietary layer[1] |
Strengths
- Category-defining adoption — 25.2K stars, 1,688 forks, and 170+ contributors as of June 2026 make Serena the most-adopted symbol-level toolkit in the open-source tier, with v1.5.3 shipped May 2026 and commits landing the day of this profile.[1][2]
- Symbol-level editing, not just retrieval — most code-intelligence MCP servers stop at search; Serena's
replace_symbol_body, rename/move/inline refactorings, andsafe_deletelet agents change code through the same semantic layer they read it with.[1] - LSP breadth for free — riding language servers means 40+ languages with IDE-grade accuracy and no proprietary indexing pipeline to maintain.[1]
- Agent-agnostic by design — one install serves Claude Code, Codex, Gemini CLI, Cursor, and JetBrains assistants alike, which is why it shows up in HN workflow threads across competing agents.[1][5]
- Token economics — community write-ups report reduced token usage and faster responses because agents pull symbol-scoped context instead of whole files.[4][5]
Cautions
- Native agent tools are catching up — the sharpest community criticism is that Claude Code's built-in search and editing improved enough that some users question whether Serena still earns its context-window overhead.[5]
- Onboarding costs tokens — the initial project onboarding reads many files and "consumes many tokens," and community guidance says Serena suits large projects more than small ones.[4]
- Only as good as the language server — semantic accuracy varies with each language's LSP implementation, and running managed language servers per project adds a moving part text-based tools don't have.[1]
- Marketplace installs are a footgun — the maintainers themselves warn against installing from MCP/plugin marketplaces due to stale commands, a sign of distribution fragmentation.[1]
- No knowledge graph — Serena answers "what references this symbol," not whole-graph questions like blast-radius scoring or architectural queries that graph-based tools in this category target.[1]
- Early-stage monetization — the paid JetBrains plugin is the first commercial layer from an undisclosed-funding maintainer; how Oraios AI funds long-term maintenance of the free core is an open question.[1][3]
What Developers Say
Serena has no single big HN launch thread; instead it recurs organically across agent-workflow discussions from August 2025 through 2026, usually as the tool people bolt onto whatever agent they run.[5]
"I've been using Serena MCP to keep my context smaller… claude uses it pretty much exclusively to search the codebase." — sixothree on Hacker News[5]
"the tools its built with seem to suck, but it can cook with serena mcp" — 8note on Hacker News, on pairing Serena with Gemini's CLI agent[5]
"I'm considering removing serena MCP, since cc got better with its own tools." — grim_io on Hacker News[5]
"How come noone mentioned serena MCP here until now :D" — PhilKunz on Hacker News, in an agent-tooling thread[5]
The grim_io comment captures the live debate: as first-party agent tooling improves, Serena's marginal value is contested for everyday tasks even by people who adopted it early.[5]
Pricing & Licensing
| Tier | Price | Includes |
|---|---|---|
| Open source | Free | Full MCP toolkit, all 40+ languages, all agent integrations, MIT license[1] |
| Serena JetBrains Plugin | Paid (free trial; price not publicly listed) | Enhanced JetBrains in-IDE experience[1][3] |
Licensing model: MIT-licensed open source on GitHub; the JetBrains plugin is the sole paid product as of June 2026.[1]
Hidden costs: the token cost of initial project onboarding, plus the context-window overhead of carrying Serena's tool definitions in every session.[4][5]
Competitive Positioning
Direct Competitors
| Competitor | Differentiation |
|---|---|
| claude-context | Embedding-based semantic search over an index; Serena uses live LSP analysis — exact symbol resolution and editing, no vector index, but no fuzzy "find code like this" retrieval |
| CodeGraph | Knowledge-graph engine for blast-radius and structural queries; Serena is shallower structurally but adds the editing/refactoring half that graph tools lack |
| Octocode MCP | Research-oriented — GitHub multi-repo search, PR archaeology, package discovery; Serena is local-first and editing-first, with deeper refactoring tools |
| Aider repo-map | Built-in, zero-setup context map for one agent; Serena is agent-agnostic and interactive (tools, not a static map) |
| First-party agent tools | Claude Code's native grep/edit improved through 2025–26; Serena's bet is that symbol-level semantics stay worth the overhead on large codebases[5] |
When to Choose Serena Over Alternatives
- Choose Serena when: agents work in large, strongly-typed codebases where rename/reference accuracy matters, you switch between multiple agents and want one shared semantic layer, or you need symbol-level editing and refactoring, not just retrieval.
- Choose claude-context when: you want embedding-based recall ("where do we handle retries?") rather than exact symbol navigation.
- Choose CodeGraph when: impact analysis and dependency-graph queries drive the workflow.
- Choose Octocode MCP when: the job is researching across many GitHub repos and PR history rather than editing one local codebase.
Ideal Customer Profile
Best fit:
- Teams running coding agents against large codebases (especially typed languages) where text search produces wrong-symbol edits
- Developers using multiple agents — Claude Code plus Codex plus an IDE assistant — who want one consistent semantic toolset
- Refactoring-heavy work: renames, moves, and deletions where atomic symbol operations beat multi-step text edits
Poor fit:
- Small projects, where onboarding token cost and tool overhead outweigh the benefit[4]
- Teams needing whole-graph impact analysis or cross-repo research (graph and search tools cover that)
- Users satisfied with their agent's native tools who want zero extra moving parts[5]
Viability Assessment
| Factor | Assessment |
|---|---|
| Financial Health | Unknown — no disclosed funding; paid JetBrains plugin is the first revenue signal[1] |
| Market Position | Leader — most-starred symbol-level toolkit (25.2K stars) with default-mention status in agent-tooling threads[1][5] |
| Innovation Pace | Steady — v1.5.x releases through May 2026, repo pushed June 11, 2026; refactoring and type-hierarchy tools added since launch[2][1] |
| Community/Ecosystem | Strong — 170+ contributors, 1,688 forks, organic presence across HN and tutorial content[1][5][4] |
| Long-term Outlook | Hinges on staying ahead of improving first-party agent tools[5] |
Fifteen months from repo creation to 25K stars and 170+ contributors is elite traction for unfunded open source, and the project's agent-agnostic position means it benefits from every new coding agent rather than competing with any of them.[1] The structural risk runs the other direction: agent vendors are internalizing better code tools, and some early adopters already report dropping Serena as native tooling improves — the MIT core's durability likely depends on LSP breadth and editing depth staying hard to replicate.[5]
Bottom Line
Serena is the standard answer to "give my agent IDE-grade code understanding": free, MIT-licensed, agent-agnostic, and the only widely-adopted tool in this category that does symbol-level editing and refactoring, not just retrieval. It should have appeared in this comparison when it crossed into category leadership in 2025; this profile corrects that omission rather than announcing anything new.
Recommended for: agent users on large or typed codebases, multi-agent workflows wanting one shared semantic layer, and refactoring-heavy tasks.
Not recommended for: small projects, teams needing knowledge-graph impact analysis, or users whose agent's native tools already suffice.
Outlook: Watch whether first-party agent tooling erodes the value proposition (the community is already debating it), how the paid JetBrains plugin evolves Oraios AI's business model, and whether the LSP-over-MCP pattern Serena standardized gets absorbed into the agents themselves.
Research by Ry Walker Research • methodology