Athena MCP
Wires into Hermes Agent as an MCP server, providing a 'think' tool that allows the Hermes agent to consult Athena for reasoning assistance on complex problems.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Athena MCPIs there a race condition in this function? If so, suggest a minimal fix."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
athena-mcp
When Hermes is stuck, it asks Athena.
An MCP server that gives your tool-using agent a reasoning sidekick. One tool: think. No side effects — Athena has no tools of her own. She just reasons.
When your main agent (Hermes, Claude Code, Cursor, any MCP-speaking client) hits a hard problem — a subtle bug, an architecture call, a plan that needs critique — it calls think and gets back a concise, well-reasoned response. Your agent stays in the driver's seat; Athena is the quiet consultant it turns to when the problem is thornier than its default model handles well.
Inspired by Codebuff's thinker agent, which does exactly this internally: Codebuff's orchestrator spawns thinker-gpt with no tools after gathering context, and the thinker's sole job is to think hard and return a brief answer.
Why the separation?
Most agents run on one model for everything. That model is a compromise: fast and cheap enough for hundreds of tool calls, smart enough for most of them. But when it's genuinely stuck, you want a different model — a reasoning-heavy one (Claude Opus, GPT-5, Gemini Pro, DeepSeek R1) — without ceding control of the rest of the task. That's what Athena is for.
Cost — reasoning models are expensive to run on every turn. Call them only when needed.
Latency — reasoning models think slowly. Save them for hard problems.
Tool orthogonality — Athena has no tools on purpose. The caller stays in control of side effects.
Model portability — swap reasoning models per call without reconfiguring your whole agent.
Related MCP server: think-mcp-server
Two backends
claude-code (default when the claude CLI is on PATH) — spawns claude -p for each call and uses your Anthropic Pro/Max subscription OAuth. No API key, no per-token billing. Just counts against your subscription quota. Supports opus, sonnet, haiku, or full Claude model names.
openrouter — HTTPS call to OpenRouter. Any model (Claude, GPT, Gemini, DeepSeek, Qwen, whatever) via per-token billing. Requires OPENROUTER_API_KEY.
Pick explicitly with ATHENA_BACKEND=claude-code or ATHENA_BACKEND=openrouter.
Install
git clone https://github.com/DevvGwardo/athena-mcp.git ~/projects/athena-mcp
cd ~/projects/athena-mcp
npm install
npm run buildEnvironment
Var | Backend | Default | Notes |
| both | auto |
|
| both |
| Model to use |
| both |
|
|
| claude-code | auto (PATH lookup) | Absolute path to |
| claude-code | 180000 | Subprocess timeout |
| openrouter | — | Required |
| openrouter | — | OpenRouter analytics headers |
Wire into Hermes
Hermes speaks MCP over stdio natively (Nous Research Hermes Agent).
With a Claude subscription (recommended):
hermes mcp add athena \
--command /path/to/node \
--args /path/to/athena-mcp/dist/index.js \
--env ATHENA_CLAUDE_CLI=/opt/homebrew/bin/claudeWith OpenRouter:
hermes mcp add athena \
--command /path/to/node \
--args /path/to/athena-mcp/dist/index.js \
--env ATHENA_BACKEND=openrouter OPENROUTER_API_KEY=sk-or-v1-... ATHENA_MODEL=anthropic/claude-opus-4.6Verify:
hermes mcp list # should show `athena`
hermes mcp test athena # should report "Connected" and 1 toolStart a new Hermes session and the agent will see a think tool.
Wire into Claude Code
claude mcp add athena --command node --args /path/to/athena-mcp/dist/index.jsWire into any other MCP client
It's a standard stdio MCP server. Point your client at node /path/to/athena-mcp/dist/index.js.
The think tool
Field | Type | Required | Description |
| string | yes | The problem to reason about. Can be brief. |
| string | no | Code, conversation excerpt, error messages — anything Athena needs to see. She can't read files. |
|
| no | Reasoning effort. Defaults to |
| string | no | Model override for this call. Format depends on backend. |
Example call (JSON-RPC):
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "think",
"arguments": {
"prompt": "Is there a race condition in the claim() function? If so, minimal fix?",
"context": "def claim(self, rid):\n if self.claims.get(rid):\n return False\n self.claims[rid] = self.agent_id\n return True",
"effort": "high"
}
}
}Response comes back as text with a footer line: backend: ... · model: ... · effort: ... · duration · tokens.
Design notes
Stateless. Each call is independent. For conversation continuity, pass the relevant history via
context.<think>...</think>blocks in Athena's response are stripped before returning — she can use them as scratch space without polluting the output. Matches Codebuff's convention.Neutral
cwd. The claude-code backend spawns fromos.tmpdir()so projectCLAUDE.mdfiles don't leak into Athena's context.--tools ""+--disable-slash-commands+--no-session-persistenceon every claude-code call keep her truly tool-free and stateless.No retry logic. If the backend errors, the error surfaces cleanly so the caller decides whether to retry.
Development
npm run dev # tsc --watch
npm run build
npm start # runs dist/index.js (needs an MCP stdio peer)Smoke test without touching any API:
printf '%s\n' \
'{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"t","version":"0"}}}' \
'{"jsonrpc":"2.0","method":"notifications/initialized"}' \
'{"jsonrpc":"2.0","id":2,"method":"tools/list"}' \
| node dist/index.jsLicense
MIT
Credits
Pattern borrowed — with appreciation — from Codebuff by the CodebuffAI team. Their thinker agent is the canonical reference for this design.
Available Tools
1 toolthinkA
Ask Athena to think. Delegates deep reasoning to a stronger model when you hit a hard problem — architecture decisions, subtle bugs, plan critique, tricky logic. Athena has NO tools; she only reasons and returns a concise response. You must gather relevant context yourself and pass it in via the context arg. Does not modify files, run commands, or access the network beyond the reasoning call.
| Name | Required | Description | Default |
|---|---|---|---|
| prompt | Yes | The problem to think about. Can be brief — Athena will reason about it carefully. Example: "Is this race condition in the claim() function real, and if so what's the minimal fix?" | |
| context | No | Optional. Relevant code, conversation excerpts, error messages, or other material Athena needs. Athena cannot read files, so anything it needs to see must be pasted here. | |
| effort | No | Optional reasoning effort override. Defaults to high. Use "high" for the hardest problems, "low" for quick sanity checks. | |
| model | No | Optional model override. Defaults to anthropic/claude-opus-4.6. Accepted values for current backend (openrouter): anthropic/claude-opus-4.6, openai/gpt-5.4, google/gemini-3.1-pro-preview, deepseek/deepseek-r1. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key traits: Athena 'only reasons and returns a concise response,' has 'NO tools,' and 'Does not modify files, run commands, or access the network beyond the reasoning call.' It also notes that 'You must gather relevant context yourself.' However, it lacks details on rate limits, authentication needs, or error handling, which would elevate it to a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, with the first sentence stating the core purpose. Each subsequent sentence adds critical information without redundancy: usage context, limitations, and parameter guidance. There is zero waste, and the structure flows logically from general to specific details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (reasoning delegation with no output schema) and lack of annotations, the description is mostly complete. It covers purpose, usage, behavioral traits, and some parameter context. However, without an output schema, it doesn't detail return values or error formats, which is a minor gap. For a tool with no annotations and no output schema, this is strong but not perfect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all four parameters thoroughly. The description adds minimal value beyond the schema, mentioning the 'context' arg briefly ('You must gather relevant context yourself and pass it in via the `context` arg.') but not explaining other parameters. This meets the baseline of 3 for high schema coverage, as the description doesn't significantly enhance parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Ask Athena to think. Delegates deep reasoning to a stronger model when you hit a hard problem — architecture decisions, subtle bugs, plan critique, tricky logic.' It specifies the verb ('think', 'delegates deep reasoning') and resource ('Athena', 'stronger model'), and distinguishes it from alternatives by noting 'Athena has NO tools; she only reasons and returns a concise response.' With no sibling tools, this level of specificity is excellent.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: 'when you hit a hard problem — architecture decisions, subtle bugs, plan critique, tricky logic.' It also clearly states when not to use it: 'Does not modify files, run commands, or access the network beyond the reasoning call.' With no sibling tools, this covers all necessary usage context, including exclusions and prerequisites like gathering context manually.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
1 tool update
v0.3.0- First observed
think
TDQS
Scored across 1 tool
With only one tool, there is no possibility of confusion or overlap between tools. The single tool 'think' has a clearly defined and distinct purpose focused solely on deep reasoning without any competing alternatives.
A single tool inherently exhibits perfect naming consistency, as there are no other tools to compare against. The tool name 'think' is straightforward and follows a simple verb pattern without any conflicting conventions.
A single tool is generally too few for most server purposes, as it severely limits functionality and scope. While the tool is well-defined for reasoning tasks, the server lacks breadth, making it feel thin and potentially incomplete for broader applications.
The server is severely incomplete for any domain beyond basic reasoning, as it only offers a single tool for deep thinking without supporting actions like file modification, command execution, or network access. This creates significant gaps that will likely cause agent failures in practical workflows.
Maintenance
Related MCP Connectors
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Official MCP server for Agentwork — delegate tasks to AI agents with human-in-the-loop
Analytics for MCP servers. Find out which of your tools agents get wrong. MCPulse shows you which tools AI agents retry, which come back empty, and which they never call at all. Two lines inside your own server. It never sees your arguments or your results. getmcpulse.com
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that implements the 'think' tool, providing Claude with a dedicated space for structured thinking during complex problem-solving tasks to improve reasoning capabilities.131MIT
- AlicenseAqualityDmaintenanceA minimal MCP Server that provides Claude AI models with the 'think' tool capability, enabling better performance on complex reasoning tasks by allowing the model to pause during response generation for additional thinking steps.11424MIT
- FlicenseAqualityDmaintenanceAn MCP server implementation of Anthropic's Think Tool prompt engineering technique that enables Claude to break down complex problems and enhance its reasoning capabilities by providing a simple tool that echoes back thoughts.12-
- AlicenseBqualityFmaintenanceAn MCP server that provides a "think" tool enabling structured reasoning for AI agents, allowing them to pause and record explicit thoughts during complex tasks or multi-step tool use.1106MIT