Luxas: An Autonomous Research Harness That Writes LaTeX Manuscripts
An autonomous research colleague — from a question to a compiled manuscript, while you sleep.
At a glance
- What is it?
- Luxas is a TypeScript multi-agent system from Muuuun that turns a one-line topic in RESEARCH.md into a compiled PDF with citations and self-generated figures. It is a harness around Claude, not a model, and its cost profile ranges from $20 to $80 per run on the default profile.
- Who is it for?
- Adopt Luxas if you want a file-backed, crash-recoverable research loop that produces a compiled PDF from a single topic line, and you are willing to install LaTeX, Python, and tmux plus pay $20 to $80 per default run. Skip it if you need a cheap, single-model pipeline or you cannot run a detached Node process.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 10 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem Luxas targets: a research loop that survives a crash
Luxas is aimed at people who want a full research cycle, from literature crawl to compiled manuscript, without babysitting an agent. The README frames it as an "autonomous research colleague: from a question to a compiled manuscript, while you sleep." The target user is someone comfortable with a Node project, a LaTeX toolchain, and an API key, and who values a durable workspace over a chat session.
The specific problem is state. A multi-hour research run that dies at hour three is worthless if the agent's plan, notes, and intermediate results live only in a context window. Luxas answers with a file-backed workspace under the project directory, externalized brain state, and detached Node sub-agent processes. The README states there are no embeddings and no vector store, so memory is files, not a retrieval index.
That design choice has a cost. File-backed memory means the agent reads and writes plain files, which is inspectable and recoverable, but it also means there is no semantic search over accumulated notes. If you expect a vector store to surface a relevant paragraph from an earlier run, Luxas does not provide one.
How the five-layer agent stack is assembled from pi-mono
Luxas vendors four pi-mono packages as `.tgz` files under `vendor/` and assembles them into a research agent. The README describes five layers. The system prompt lives in `src/agents/definitions/brain.md` and is split into three cache-controlled blocks: a methodology body with a one-hour cache, a block holding RESEARCH.md plus skills, and a mutable block containing `<active_agents>` and `<plan_status>` that is rebuilt in place.
The tool layer sits in `src/t...` according to the truncated README, and the package manifest confirms the vendored dependencies: `@earendil-works/pi-agent-core`, `@earendil-works/pi-ai`, `@earendil-works/pi-coding-agent`, and `@earendil-works/pi-tui`, all at version 0.84.2 and referenced as `file:vendor/...` entries. The project depends on `better-sqlite3`, `ink`, `node-pty`, and `react`, which points at a terminal UI and a PTY-backed shell tool.
The independent-author pattern is the part worth understanding. The README says implementation and tests are written by sibling agents "blind to each other," and that `figure_auditor` is deliberately kept on an Anthropic tier because "an auditor running the same model that drew the figure is not an independent one." That is a real structural claim about self-review, not a prompt instruction. Deterministic finish-gates are described as gates "that no prompt can talk past."
Installing Luxas and running a first project
The README is explicit that `npm install` alone is not enough, because agents shell out to LaTeX, Python, and tmux. On macOS the documented setup uses Homebrew:
brew install --cask mactex # or basictex for ~150MB
brew install poppler tmux python@3.11
pip3 install matplotlib numpyOn Debian or Ubuntu the README gives an apt equivalent:
sudo apt install texlive-latex-extra texlive-fonts-recommended poppler-utils tmux python3-matplotlib python3-numpyAfter the system dependencies, clone the repository and link the CLI. The README notes you can skip `npm link` and use `npx tsx src/index.ts` instead.
git clone https://github.com/Muuuun/luxas.git && cd luxas
npm install && npm link
export ANTHROPIC_API_KEY="..."
luxas init ~/research/x --prompt "Survey LLM chain-of-thought reasoning"
luxas run ~/research/x --model opusThe `init` command creates a project directory with a prompt, and `run` starts the loop. The README lists `luxas status ~/research/x` for progress, `luxas figures ~/research/x` to rerun only the figure and typesetter loop, and `luxas list` for every project Luxas has touched. The `package.json` also exposes `npm run tui` and `npm run dev`, but the README's quick start does not mention them.
Switching models is a family-wide redirect rather than a per-agent edit. The README documents `--profile dual`, which sets DeepSeek text plus a vision model, and warns that `--model deepseek-v4-pro` without a vision override means "figures break."
Cost, model profiles, and the vision gap
The README gives an anecdotal cost table and tells you to check `<project>/.agent/usage.log` for real numbers. The default full-Claude profile is listed at $20 to $80 per run and is described as the only profile with Anthropic prompt caching. The `--profile dual` preset is listed at $2 to $10 but loses ephemeral `cache_control`.
This is the sharpest trade-off in the project. `--profile dual` and any `--model deepseek-*` redirect every agent that declared `haiku`, `sonnet`, or `opus` to the DeepSeek model through `applyProfile()` in `src/agents/spawn.ts`. Provider-specific picks bypass the redirect: the README names `gpt-5.2` for the `math` agent and `o3` for reasoning, and calls those deliberate.
The vision problem is the one to plan around. DeepSeek text models cannot see, so `illustrator`, `illustrator_write`, and `typesetter` need a separate vision profile. `--profile dual` sets that to `glm-5.3-flash`. Running `--model deepseek-v4-pro` alone gives you the same text redirect with no vision override, and the README states plainly that figures break. If figure quality is the point of your run, the cheap profile is not a drop-in replacement.
Where Luxas is the wrong tool
Luxas is a harness, not a model. The README says the intelligence comes from Claude, OpenAI o3 for math, or a redirected DeepSeek or Kimi model via an environment variable. If you have no API key and no budget, the project does nothing for you. There is no local-model story in the README.
The dependency surface is also heavy for what looks like an npm package. Agents shell out to LaTeX, Python, and tmux, so a container without a TeX distribution will fail at the typesetting stage, not at install. The README's warning that `npm install` alone is not enough is the clearest signal that this is a workstation tool, not a library you import.
The crash-recovery design is honest about its own friction. The README notes that a few of the nine gallery runs "required restarts or `pi_pushback.md` iterations when the reviewer and brain genuinely disagreed," and that "the harness is built around those crashes rather than against them." If you want a pipeline that never needs a human decision, this is not that pipeline. Someone has to look at `pi_pushback.md` when the reviewer and the brain disagree.
Finally, the project is at version 0.1.0 in `package.json`, and no releases were retrieved. Treat the CLI surface as moving.
How Luxas differs from LangGraph, CrewAI, and Sakana AI Scientist
The README positions Luxas against LangGraph, CrewAI, AutoGPT, Sakana AI Scientist, and Claude Code, and points to a Comparison section for the details. The visible difference in the README is architectural. LangGraph and CrewAI are general orchestration frameworks where you define the graph or the crew; Luxas ships a fixed research pipeline with named roles such as `brain`, `illustrator`, `figure_auditor`, and `typesetter`, each declared in a `.md` file with a frontmatter model.
That fixed pipeline is both the value and the constraint. You get an opinionated loop with deterministic finish-gates and an independent-author pattern out of the box. You do not get to swap the research methodology for a different workflow without editing agent definitions.
Against Sakana AI Scientist, the README's framing is that Luxas is a harness giving intelligence a durable workspace, with file-backed memory and detached sub-agent processes. The concrete difference a reader can verify from the repository is the vendored pi-mono layer and the `vendor/` `.tgz` dependencies, which tie the agent loop and tool lifecycle to Mario Zechner's primitives rather than a bespoke loop.
Licence and upgrade cost
Luxas is MIT licensed, and the repository contains a `LICENSE` file and a `CITATION.cff`. MIT is permissive, so the practical implication is that you can use, modify, and redistribute the code with the copyright notice. That is a statement about the project's licence, not legal advice about your situation.
The upgrade cost is worth noting before you build on it. The four pi-mono packages are vendored as `.tgz` files at version 0.84.2, not pulled from a registry. Updating the agent loop means replacing those tarballs and re-running the patches. The `postinstall` script runs two patch scripts, `patches/pi-coding-agent-read-limits.sh` and `patches/pi-agent-core-no-tool-retry-guard.sh`, which means the installed dependencies are modified after install. Any upgrade that changes those vendored packages can invalidate the patches.
There is also a `scripts/run-gates.mts` test runner exposed as `npm test` and `npm run test:live`. The gates are the project's own definition of a correct run, so a version bump that changes gate behaviour is the thing to watch, not a changelog, which the repository does not provide.
Editorial conclusion
Adopt Luxas if you want a file-backed, crash-recoverable research loop that produces a compiled PDF from a single topic line, and you are willing to install LaTeX, Python, and tmux plus pay $20 to $80 per default run. Skip it if you need a cheap, single-model pipeline or you cannot run a detached Node process. Verify first that `luxas status` reports progress after `luxas init`, and check `<project>/.agent/usage.log` for your actual spend before committing to a long run.
Frequently asked questions
What is Luxas used for?
Luxas is a multi-agent system for autonomous scientific research. Give it a topic in RESEARCH.md and it crawls the literature, reads papers, designs and runs experiments, produces figures, and writes a LaTeX report that is compiled to a PDF with citations.
What does Luxas stand for?
The README does not state that Luxas is an acronym. It describes the project as an autonomous research agent, and the package description calls it an agent that never stops pushing the boulder of knowledge.
What is the meaning of Luxas?
The repository does not give an etymology or expansion for the name. What it does document is what the tool does: it takes a one-line topic and produces a compiled manuscript end to end.
What is Luxas made of?
Luxas is a TypeScript project that vendors four pi-mono packages as .tgz files under vendor/ and depends on better-sqlite3, ink, node-pty, and react. The README describes it as a harness, with the model intelligence coming from Claude, OpenAI o3 for math, or a redirected DeepSeek or Kimi model.
Community notes