Systematic Toolchain for AI Research

STAR

Every STAGE needs a STAR

A reusable foundation for reproducible, well-structured AI research: one predictable layout, one experiment entrypoint, and a fifteen-skill workflow that carries a vague idea all the way to a released repository, with every decision on file. When the results are ready to write up, STAGE picks them up as fingerprinted evidence and writes the paper on top.

✦ Get Started View on GitHub
15Workflow Skills
7AI Agents Supported
2Languages · EN 中文
MITOpen Source

The STAR family

One research life cycle.
Three focused toolchains.

Each works independently. Connect them when you want upstream work to flow downstream as fingerprinted, read-only evidence.

01 · RESEARCH Current

STAR

Systematic Toolchain for AI Research

Runs one research project from idea through reproducible experiments to paper-ready evidence.

Website ↗ GitHub ↗
02 · PAPER

STAGE

Systematic Toolchain for Authoring, Guiding, and Editing

Turns one contribution into a traceable paper, review cycle, and submission package.

Website ↗ GitHub ↗
03 · THESIS

STORY

Systematic Toolchain for Organizing Research over Years

Shapes graduate research into a defensible master's thesis or doctoral dissertation, defense, and deposit.

Website ↗ GitHub ↗

Why STAR

Everything in its place.
Every decision on file.

Research code rots when structure lives in someone's head and context lives in a chat window. STAR moves both into the repository itself.

A consistent layout

Code, data, weights, outputs, and methodology notes each have one predictable home: code/, datas/, inits/, wkdrs/, metds/.

A portable runtime boundary

Machine-specific paths live in a local .env, never in scripts. Clone the repo anywhere, point it at your conda or venv, and run.

One experiment entrypoint

bash execs/run.sh <exp> activates the environment, exports the path variables, and launches any experiment script the same way, every time.

A traceable, resumable research process

Plans live in metds/plans/, execution intermediates in tasks/, run artifacts in wkdrs/. Key decisions, task dependencies, and validation records persist in project files (not in chat history), so any session, human or agent, can pick up exactly where the last one stopped. What a session learns that no plan or report owns (an environment quirk, a standing preference, a dead end) is recorded in .star/memory/, and a session hook puts it in front of the next agent.

AI-agent native

Shared instructions and identical skill sets ship for Codex, Claude, Kimi, Cursor, DSH, Pi, and Qwen Code, all in English and Chinese. Your agents follow the same conventions you do, and two dials in .env set the terms: INVOLVE decides how much a run asks you before it decides, STAR_LANG which language it writes. STAR stays framework-agnostic underneath: bring your own model stack, dependency manager, and experiment tracker.

Safe defaults for large artifacts

Local data, model weights, generated outputs, and environment settings are excluded from version control out of the box. Adopt an existing project with symlinks; nothing gets moved, nothing gets overwritten. A commit guard declines what is expensive to undo: blanket staging, history rewrites, and any commit that would put a checkpoint into your history.

Upgradeable without disruption

bash execs/update.sh syncs newer STAR skills and workflow guides into an existing project without touching your code, experiments, or Git remotes.

Project structure

Eight directories.
Zero guessing.

The abbreviated names are deliberate: short to type, unambiguous to search, and identical across every STAR project.

tree ~/my-research
STAR/ ├── code/ # core source (named by CODE_NAME) ├── datas/ # datasets & data files ├── inits/ # weights & checkpoints ├── metds/ # methodologies │ ├── ideas/ # topic explorations │ ├── plans/ # research plans & sub-plans │ └── refs/ # related-work notes + reference.bib ├── execs/ # executions │ ├── run.sh # ← the single entrypoint │ ├── update.sh │ └── scpts/ # experiment scripts ├── tasks/ # per-plan execution intermediates ├── wkdrs/ # run outputs: logs, metrics, figures ├── docs/ # documentation site ├── .env # machine-local paths (never committed) └── AGENTS.md # shared human + agent instructions
datas/Data: raw, processed, or generated datasets
inits/Initializations: pretrained weights and checkpoints
metds/Methodologies: plans, design notes, research records
execs/Executions: launchers and experiment scripts
scpts/Scripts: individual runnable experiment definitions
tasks/Tasks: each plan's tool scripts and working files
wkdrs/Work directories: logs, metrics, predictions, artifacts

Research workflow

Fifteen skills.
One constellation.

Each skill writes its evidence into project files, so the whole research programme is auditable and resumable at any point.

✦

ShapeConverge on a topic and turn it into verifiable plans.

$star-proj-adopt

Adopt an already-started project without disturbing it: survey, symlink, record.

$star-idea-storm

Converge a vague interest into a defensible research topic, scored on six dimensions.

$star-plan-coach

Clarify the idea through staged questions into a strategic research plan.

$star-refs-reviewer

Survey related work into analysis notes and a verified, classified bibliography.

✦

BuildStand up the codebase and the runtime it needs.

$star-code-architect

Set up the codebase from a scored reference implementation, or survey and reorganize the code already there, and record the architecture.

$star-env-builder

Build the conda env or venv from .env, resolve dependencies, verify it runs.

$star-plan-decomposer

Split strategic plans recursively into verifiable, executable sub-plans.

✦

ExecuteImplement each leaf plan and audit what it produced.

$star-plan-executor

Implement and lightly validate one executable leaf plan, logging every run.

$star-code-reviewer

Review code against project conventions and the plan's promised implementation, then apply mechanical fixes: minor ones unasked, major ones as approved.

$star-expt-analyst

Audit a run against what the plan expected: artifacts, logs, metrics, meaning.

✦

SteerKeep the plan tree honest against execution evidence.

$star-plan-reviser

Revise a plan in place against its execution evidence, with a revision history.

$star-expt-digest

Summarize what the programme has done lately: verdicts, movement, gaps.

$star-flow-status

Report progress across the whole flow and the single next action to take.

✦

DeliverTurn matured plans into papers and releases.

$star-metd-summarize

Compile the plan tree into paper-ready method documents, flagging the unverified.

$star-code-release

Prepare the repository for release: promote code, polish, compile the README, sweep for secrets.

STAR research workflow: thirteen skills in running order plus two that read across them, what each writes, and how the per-leaf loop closes
The full workflow map: running order, outputs, and how the per-leaf loop closes.

Quick start

Six commands to liftoff.

Start fresh from the template, or run update.sh --adopt inside an existing repository and STAR installs itself around your work without moving a single file.

zsh — my-research
# 1 · Start a project from the STAR template ❯ git clone https://github.com/wanghao9610/STAR my-research && cd my-research ❯ rm -rf .git .github && git init # drop STAR's history and its maintainer CI # 2 · Name your source package, then configure the local runtime ❯ mv code my_pkg ❯ cp .env.example .env && $EDITOR .env # CODE_NAME=my_pkg, then PYTHON_HOME (or CONDA_HOME + ENV_NAME) # 3 · See what's runnable ❯ bash execs/run.sh --list # 4 · Launch through the single entrypoint — 00_exp prints the resolved paths ❯ bash execs/run.sh 00_exp ❯

Ready when you are

Give your research a
structure worth returning to.

STAR is free, MIT-licensed, and framework-agnostic. Use it as a GitHub template, or adopt it into the project you already have.

✦ Use the Template Read the Docs Pair it with STAGE