Houtini LM: delegating tasks to another model
Houtini LM
An MCP server that hands bounded tasks to a local model or a cheap cloud API, while Claude stays the architect and saves tokens
- 122 ★ on the repository
- Last commit
- Apache-2.0
Extended access
Why this level
- The `code_task_files` tool reads files from disk and sends them to the chosen model: with a cloud API the source goes to a third party
- A cloud API key sits in the MCP client configuration
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add mcp/houtini-lmDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The `code_task_files` tool reads files from disk and sends them to the chosen model: with a cloud API the source goes to a third party
- A cloud API key sits in the MCP client configuration
This is third-party code. Review the repository files before installing.
What it does
Houtini LM hands bounded work to another model: a local one on your GPU, OpenAI GPT, a LiteLLM router, OpenRouter or a cheap cloud API. Claude Code, Claude Desktop or Cursor keep planning and deciding, while the connected model does the drafting. Any OpenAI-compatible endpoint works: LM Studio, Ollama, vLLM, SGLang, llama.cpp, DeepSeek, Groq. The main gain is tokens. The `code_task_files` tool reads files from disk itself and sends them to the other model, so source code never enters Claude's context. In the author's table a review of 1,352 lines costs 769 tokens instead of 14,466, and the session average is 93.3% saved. The second gain is a second opinion: another model reads code with different blind spots. The server has eight tools: `chat`, `custom_prompt`, `code_task`, `code_task_files`, `embed`, `discover`, `list_models` and `stats`. For local models it reads the installed list, looks each one up on HuggingFace, caches the result in SQLite and picks the best fit for the task type, and only suggests a model swap because loading takes minutes.
Who it is for. Developers whose Claude Code runs for hours on large refactors and whose token bill grows because of routine work like reviews and drafts.
Good fit when
- Reviewing a big file costs Claude tens of thousands of tokens and can go to a local model
- You want a second opinion on a plan or code from another model at low cost
- You need test stubs, docstrings or commit messages from a diff quickly
- Code must not go to an outside cloud service and a model runs on a GPU under your desk
- A RAG pipeline needs text embeddings through `/v1/embeddings`
Not a fit when
- The work needs reasoning across the repository, tool calls or multi-step orchestration: that stays with Claude
- The task is one line long: the roughly 250-token call overhead is about the size of the answer
- You have neither a local model nor a cloud API key: the server has nothing to delegate to
Example request
Send the review of src/payments.ts to the local model through houtini-lm and show only the bugs found, with line numbers.MCP
- Transport
- stdio
- Authentication
- key is optional
Environment variables
HOUTINI_LM_ENDPOINT_URL- Address of the OpenAI-compatible endpoint, http://localhost:1234 by default.
HOUTINI_LM_API_KEYsecret- Endpoint key, if it requires authentication.
HOUTINI_LM_MODEL- Model pinned for calls, for example with OpenAI.
Limitations
It needs Node 22.5 or newer and an OpenAI-compatible endpoint: a local server or a cloud API key. Local inference is usually 3 to 30 times slower than a frontier model, so only bounded, self-contained tasks pay off.
Some setups send code to a third-party cloud: with OpenAI or DeepSeek the source leaves your machine, while a local model keeps it with you. The key is set through `HOUTINI_LM_API_KEY` and ends up in the MCP client configuration.
The savings figures come from the author's measurements on his own tasks and depend on file size and the chosen model.
How to disable. Remove the server with `claude mcp remove houtini-lm`. If a cloud API key was stored in the client configuration, revoke it with the provider.
FAQ
Which models work?
Any behind an OpenAI-compatible endpoint: LM Studio, Ollama, vLLM, SGLang, llama.cpp, a LiteLLM router, OpenRouter, plus DeepSeek, Groq, Cerebras and OpenAI. GPT-5 and the o-series get special parameter handling.
How do I check it is wired up?
Ask the agent to call `discover`: it returns the server version, the endpoint found, the active model and its context window size.
What should I hand over?
Bounded tasks with clear input and output: code review, test stubs, explaining a function, commit messages, format conversion, mock data, type definitions, structured JSON and embeddings.
Where does it look for LM Studio?
It checks `localhost:1234` first, the LM Studio default. For another address set `HOUTINI_LM_ENDPOINT_URL`, add a key in `HOUTINI_LM_API_KEY` if needed, and pin the model with `HOUTINI_LM_MODEL`.
How does thinking mode work?
It is set with `HOUTINI_LM_THINKING`. The default `auto` switches thinking off for models that support the toggle, such as Qwen3, Gemma 4 and DeepSeek R1, because Claude already does the reasoning.
Discussion
No questions or reviews yet.
Related
MCP serversllmman runs Claude Code, Codex and OpenCode on a local or hosted model with one command and stores models as OCI images
lilbee runs local models across several GPUs and gives agents MCP search over your files with a file and line citation
LM Studio is a desktop app for running open models locally, with a chat, a local server in OpenAI and Anthropic formats, and MCP support.
Hooks read each prompt before the model and ask a free or local model for a draft first, saving Claude subscription quota.
An MCP server that runs DeepSeek or your own local model as a sub-agent in Claude Code and Codex with its own tool loop.
An MCP server that sends one prompt to several OpenAI, Anthropic, Gemini, Groq, DeepSeek and Ollama models at once and can draw a decision from them
README in short
The README explains why the author built the server: overnight refactors in Claude Code ran up a heavy token bill. It then gives a savings table, a flow diagram, install steps for LM Studio, OpenAI and other routes, a list of tasks to hand over and the eight tools.