Introduction
Polaris is an autonomous scientific-discovery (deep research) platform built for individual researchers, desktop first. It runs the entire research lifecycle in one application: literature survey, idea generation, idea review, experiments on real GPU servers, LaTeX paper writing, and paper review. Each stage produces durable artifacts that the next stage consumes — so you can go from "new direction" to "reviewed draft" without stitching together notebooks, chat windows, and shell sessions. Polaris is a desktop app: a self-contained offline build with its own local engine (no account, no server to set up).
What makes it different
Deterministic heavy lifting, LLM judgement calls. The expensive mechanical work — crawling, parsing, deduplication, watermark-based incremental sync, metric parsing, citation matching — is ordinary code running as background tasks. LLMs are reserved for the decisions that actually need judgement: relevance scoring, synthesis, drafting, and review. Guardrails live in code, not prompts: experiment numbers may only come from real run metrics, and citations must map to real knowledge-base entries. This split keeps runs cheap, reproducible, and auditable.
Every long task is a Voyage. Research tasks are long-running by nature — a cold-start literature backfill takes hours, an experiment runs for days. Polaris treats every such task as a Voyage: a persisted, resumable, human-gated agent run backed by a state machine. If the app quits or crashes mid-run, the run resumes from its last checkpoint. Budgets auto-pause it when exceeded, steps that need a human create an approval gate, and when the agent is genuinely stuck it asks you a question instead of failing. Every plan, action, and verdict is retained and replayable in the UI. The full loop — Navigator plans, Helm executes, Sextant verifies — is explained in Core concepts and, at implementation depth, in The task system.
Built for individual researchers. There is no login at all — the computer's owner is the only user and their own admin. You get encrypted SSH credentials, per-call token and cost accounting attributed to project and run, and your own libraries (with optional monthly AI budgets).
Bring your own agent. The easiest way to give Polaris a model is an agent you already use: Claude Code, Codex, Gemini CLI and other ACP agents answer model calls with no API key, and can also drive the assistant. Model APIs are optional. See Agent backends.
The pipeline, stage by stage
| Stage | What Polaris does | Guide |
|---|---|---|
| Literature | The Research Wiki ingests papers from OpenAlex, Semantic Scholar, and arXiv, scores relevance against each direction library's inclusion config, extracts full text and figures, and compiles a cross-linked wiki page per paper — one wiki per paper, shared platform-wide. A daily arXiv feed keeps libraries current. | Literature guide |
| Idea | Idea Forge runs multi-signal gap analysis over the knowledge base (concept co-occurrence holes, paper limitations, trend velocity), generates ideas with retrieval-planned prompts, scores them on four axes, deduplicates semantically, and hardens the winner into a full research proposal. | Ideas guide |
| Idea review | Configurable-persona reviewer agents debate ideas pairwise; a judge produces an Elo tournament ranking. Lab members join the discussion live, and their comments enter the agent context as first-class input. Promotion to experiment passes a human gate. | Ideas guide |
| Experiment | The Experiment Lab reaches your lab's GPU servers over per-user encrypted SSH. An experiment run plans the study (optionally pausing at a compute-budget approval if you ask for one), writes code, smoke-tests it, launches runs with streamed logs and live metric curves, then iterates on the results — and pauses to ask you a question when it is stuck. | Experiments guide |
| Paper writing | A multi-file LaTeX project (NeurIPS, ICLR, ACL templates) with collaborative editing and server-side tectonic compilation to a live PDF. An agent drafts section by section, but numbers may only come from real experiment metrics and citations from real knowledge-base entries. | Writing guide |
| Paper review | Line-by-line citation verification (existence and support, per citation), deterministic fact-checking of every number against the experiment record, then multi-perspective reviewer agents and a meta-review. A fabricated citation forces a non-pass. | Paper review guide |
The Voyage agent core
Every complex task above runs on the same engine. Three roles drive a persisted loop:
| Component | Role |
|---|---|
| Navigator | Planning. Decomposes a goal into a step plan with sub-goals, dependencies, and budget; edits the plan incrementally as evidence arrives instead of replanning from scratch. |
| Helm | Execution. Runs a single step — LLM calls, tool calls, SSH remote operations, literature-API queries — and returns an observation. |
| Sextant | Self-verification. Checks each step against structured acceptance criteria (exit code, artifact exists, schema valid, metric threshold, count, LLM rubric). Deterministic checks run first; failures feed diagnostics back to Navigator, and repeated failure on the same error escalates to a question for a human. |
Not every task needs the full cognitive loop. A shared runtime shell (state machine, checkpointing, gates, budgets, cancellation, event streaming) serves all task kinds, while the full plan–execute–verify brain activates only for open-ended kinds such as experiments. Predictable pipelines — wiki compilation, idea review, paper drafting — run on fixed step templates instead of being over-orchestrated. The task system documents the data model, run modes, budgets, and failure handling in full.
Try it live
A guest account on a running instance, for looking around: sign in at http://101.37.174.109:8080 with the username guest and the password zjuguest123. The account is read-only and cannot call any model — it reaches every screen, admin views included, but creating, editing, and uploading are refused, and no LLM call will run. It shows what the platform looks like; to do real work, run your own instance.
Beyond the pipeline
- PolarisBuddy — an in-app assistant that rides along on every page: a multi-turn tool loop over the platform's read-only tool layer, with chat, plan, and goal modes, page context, and persistent per-user memory.
- Skills — agent behavior packaged as data, not code: guidance, rubric, persona, and workflow packs injected into agent prompts, with a marketplace and per-run snapshots for reproducibility.
- MCP — the same read-only tool layer exposed as an MCP server (Streamable HTTP and stdio), so Claude Code, Codex, or Cursor can read your research workspace directly.
Where to go next
| If you want to… | Read |
|---|---|
| Install the app and give it a model | Getting started |
| Understand the mental model (pipeline, Voyages, skills, tools) | Core concepts |
| See how the system is put together | Architecture |
| Configure environment variables and model routing | Configuration |
| Use Claude Code or another agent as the model | Agent backends |
| Understand how the desktop app runs its engine | Desktop |
| Extend the desktop app with plugins | Plugins |
TIP
New to Polaris? The shortest useful path is: get it running, create a direction library and let the literature stage build your corpus (Literature guide), then work forward through the pipeline one stage at a time.