@paradigma-inc/flywheel 0.1.4 → 0.1.9

package/README.md

@@ -1,39 +1,144 @@
 # flywheel setup CLI
 
-This package provides setup and uninstall workflows for Flywheel MCP.
+This package configures Flywheel MCP for supported AI coding hosts and can
+install or refresh all bundled Flywheel skills during setup.
 
-## Usage
+## Public Guided Install (Primary Human Flow)
 
 ```bash
-npx @paradigma-inc/flywheel setup
-npx @paradigma-inc/flywheel uninstall
+npx --yes @paradigma-inc/flywheel setup
 ```
 
-`--base-url` must be the public Flywheel origin, not a backend URL or an `/api`
-path. Example:
+Guided flow:
+
+1. Flywheel MCP setup runs first.
+2. If at least one selected host supports bundled skill install, setup asks
+   one of these prompts:
+   - `Also install or refresh the bundled Flywheel skill?`
+   - `Also install or refresh the bundled Flywheel skills?`
+3. The prompt default is yes.
+
+If you accept the default, the run completes with MCP plus bundled skill setup
+for supported hosts.
+
+## Public Base URL Rules
+
+`--base-url` must be a public Flywheel origin, not a backend URL and not a URL
+with a path/query/fragment.
+
+Use public origins such as:
+
+- `https://flywheel.paradigma.inc`
+
+Do not pass backend Fly machine hostnames (for example `*.fly.dev`) to
+`--base-url`.
+
+## Explicit Automation Flows
+
+Prompt-free combined MCP plus skill setup:
 
 ```bash
-npx @paradigma-inc/flywheel@staging setup \
-  --name flywheel-staging \
-  --base-url https://flywheel-staging.paradigma.inc
+npx --yes @paradigma-inc/flywheel setup --install-skill
 ```
 
-## Commands
+Prompt-free MCP-only setup:
 
-- `setup`: interview + browser auth bridge + idempotent host config writes.
-- `uninstall`: remove Flywheel MCP entries from selected host configs.
-- Add `--yes` to skip interactive prompts in the Flywheel wizard.
-- `npx --yes` only auto-confirms `npx`; it does not imply `flywheel --yes`.
+```bash
+npx --yes @paradigma-inc/flywheel setup --skip-skill
+```
+
+`--install-skill` and `--skip-skill` are mutually exclusive.
+
+Non-interactive setup requires one of those flags.
+
+## Auth Modes And Remote Shells
+
+`setup --auth-mode auto|loopback|device` controls authentication behavior:
+
+- `loopback`: opens `/auth/mcp/setup` and waits for a localhost callback.
+- `device`: opens `/auth/mcp/setup/device`, confirms a setup code in browser,
+  and CLI polls for approval.
+- `auto` (default): uses `device` on SSH shells and `loopback` otherwise.
+
+Remote/headless example:
+
+```bash
+npx --yes @paradigma-inc/flywheel setup \
+  --auth-mode device \
+  --base-url https://flywheel.paradigma.inc
+```
+
+## Scope Rules
+
+- Default scope (no `--project`) is user-level/global:
+  MCP config is written to the host's global config path and bundled skill
+  install targets user-level skill directories.
+- `--project` is the explicit repo-local override:
+  MCP config and bundled skill install both target project-local paths.
+
+Examples:
+
+```bash
+# Global default
+npx --yes @paradigma-inc/flywheel setup --install-skill --codex --api-key <token>
 
-## Supported hosts
+# Project-local override
+npx --yes @paradigma-inc/flywheel setup --install-skill \
+  --project --codex --api-key <token>
+```
+
+## Public Update Flow
+
+After a new release:
+
+- Human-guided update:
+
+```bash
+npx --yes @paradigma-inc/flywheel@latest setup
+```
+
+- Automation update:
+
+```bash
+npx --yes @paradigma-inc/flywheel@latest setup --install-skill
+```
+
+Reruns refresh every already-installed bundled skill in place and install any
+newly bundled skills from the updated package. They do not create side-by-side
+copies for the same scope and agent location.
+
+## Supported Hosts For Bundled Skill Install
 
-- Codex (`~/.codex/config.toml` or `.codex/config.toml`)
-- Claude Code (`~/.claude.json` or `.mcp.json`)
-- OpenCode (`~/.config/opencode/opencode.json` or `opencode.json`)
-- Cursor (`~/.cursor/mcp.json` or `.cursor/mcp.json`)
-- Hermes Agent (`~/.hermes/config.yaml` or `.hermes/config.yaml`)
-- OpenClaw (`~/.openclaw/openclaw.json` or `.openclaw/openclaw.json`)
-- Pi (pi-mono) (`~/.pi/agent/settings.json` or `.pi/settings.json`)
+- Claude Code
+- Codex
+- OpenCode
+- Cursor
+- OpenClaw
+- Pi (pi-mono)
 
-Pi (pi-mono) support writes `mcp.servers` into Pi settings. It requires an
-MCP-capable Pi extension/package to consume those entries.
+Hermes Agent remains MCP-only in phase 1.
+
+## Troubleshooting
+
+Advanced troubleshooting (optional): inspect installed skill state directly.
+Normal users do not need to run these commands for install/update.
+
+```bash
+npx --yes skills ls -a codex
+npx --yes skills ls -a claude-code
+npx --yes skills ls -a cursor
+```
+
+If any bundled skill is missing, rerun setup using either guided `setup` or
+explicit `setup --install-skill`.
+
+## Other Commands
+
+- `setup`: guided setup-centric flow.
+- `uninstall`: removes Flywheel MCP entries from host configs only.
+
+```bash
+npx --yes @paradigma-inc/flywheel uninstall
+```
+
+- `npx --yes` only auto-confirms `npx`; it does not imply `flywheel --yes`.

package/package.json

@@ -1,17 +1,13 @@
 {
   "name": "@paradigma-inc/flywheel",
-  "version": "0.1.4",
+  "version": "0.1.9",
   "description": "One-command setup for Flywheel MCP hosts",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/paradigma-inc/paradigma",
-    "directory": "project/flywheel-setup"
-  },
   "type": "module",
   "files": [
     "bin/",
     "src/",
-    "README.md"
+    "README.md",
+    "skills/"
   ],
   "bin": {
     "flywheel": "bin/flywheel.js"
@@ -24,7 +20,13 @@
     "commander": "^14.0.1",
     "js-yaml": "^4.1.0",
     "ora": "^9.0.0",
-    "picocolors": "^1.1.1"
+    "picocolors": "^1.1.1",
+    "skills": "1.4.7"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/paradigma-inc/paradigma.git",
+    "directory": "project/flywheel-setup"
   },
   "engines": {
     "node": ">=20"

package/skills/flywheel/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: flywheel
+description: Use for Flywheel experiment design, MCP-assisted execution, and platform setup/troubleshooting across supported hosts.
+---
+
+# Flywheel Skill
+
+Use this skill to structure research work and to route setup/support questions to the smallest relevant Flywheel docs.
+
+## When To Use
+
+Use this skill when the conversation is about any of the following:
+
+- planning experiments, hypotheses, comparisons, or next-branch decisions
+- running or interpreting empirical work in Flywheel
+- choosing between `insight` and `empirical` nodes
+- setting up, updating, authenticating, or troubleshooting Flywheel MCP
+- managed compute, local hardware, campaigns, or Flywheel Web UI navigation
+
+If the request is ambiguous, default to experiment-design guidance before platform mechanics.
+
+## Workflow
+
+1. Classify the request as research guidance, platform support, or mixed.
+2. Load only the minimum files needed for the current task.
+3. For research requests, run a short design pass before execution:
+   ask 1-2 questions to clarify objective, assumptions, and decision criteria.
+4. If design is solid and the user wants to proceed, shift to execution support.
+5. Use Flywheel MCP tools for live behavior/contract checks when available.
+6. Summarize evidence and propose the most likely next branch.
+
+## Routing Map
+
+Choose one primary file first, then add at most one supporting file only if needed:
+
+- `reference/experiment-design-protocol.md` for structured experiment design and readiness checks
+- `reference/flywheel-mcp-tool-map.md` for exact tool surface and contract behavior
+- `getting-started/flywheel-tutorial-overview.md` for orientation and learning path
+- `getting-started/flywheel-quickstart.md` for fastest first-use setup and auth recovery
+- `setting-up-flywheel/` for host-specific installation and update procedures
+- `usage-and-workflows/` for practical workflows and local hardware
+- `compute/` for managed compute and billing/credits
+- `campaigns/` for campaign participation
+- `web-ui/` for web UI guides and maps
+- `example-workflows/` for concrete, end-to-end examples
+
+## Guardrails
+
+- Keep guidance harness-agnostic unless the user explicitly asks for a specific host.
+- Prefer concrete steps and decision points over long narrative explanations.
+- Do not run broad document reads; load only what is required by the current request.
+- Do not start compute-heavy execution before design intent is clear.

package/skills/flywheel/agents/openai.yaml

@@ -0,0 +1,15 @@
+interface:
+  display_name: "Flywheel"
+  short_description: "Guide Flywheel experiment design, setup, tools, and workflows"
+  default_prompt: "Use $flywheel to answer Flywheel experiment, setup, MCP tool, compute, campaign, or Web UI questions."
+
+dependencies:
+  tools:
+    - type: "mcp"
+      value: "flywheel"
+      description: "Flywheel MCP server"
+      transport: "streamable_http"
+      url: "https://flywheel.paradigma.inc/mcp-server"
+
+policy:
+  allow_implicit_invocation: true

package/skills/flywheel/campaigns/participating-in-a-campaign.md

@@ -0,0 +1,18 @@
+# [](https://flywheel.paradigma.inc//#participating-in-a-campaign)Participating in a Campaign
+
+Campaigns are challenge-style Flywheel graphs where an organizer shares a root graph, defines the objective and submission contract, and may fund participant compute through campaign budgets.
+
+To participate in a campaign:
+
+1. Get access to the campaign root. Invite-only campaigns are shared directly with your Flywheel account. Open campaigns are made public by the organizer.
+2. Open the campaign in the WebUI or ask your MCP host to inspect the root node.
+3. Read the campaign root carefully before you start. Organizers can define the objective, submission format, graph hygiene, repo policy, GPU guidance, and any evaluation rules directly on the root.
+4. Do your work in your own part of the graph. Use Flywheel nodes to record your progress, artifacts, summaries, and conclusions so your submission stays reviewable.
+5. If the campaign provides compute funding, discover the available budget grants and acquire compute against the campaign grant your MCP host shows you.
+
+The practical rule is simple: the campaign root tells you the contract, and your graph is how you show your work.
+
+## [](https://flywheel.paradigma.inc//#coming-soon)Coming Soon
+
+- A dedicated tutorial section for setting up a campaign as an organizer.
+- A dedicated tutorial section for sponsoring or funding a campaign.

package/skills/flywheel/compute/credits-and-billing.md

@@ -0,0 +1,11 @@
+# Credits and Billing
+
+Compute is billed against your Flywheel credits balance, which is separate from your subscription.
+
+- The **Pro subscription** ($20/month or $204/year) includes $10 in non-rollover credits each Pro cycle.
+- Those credits refresh when the plan renews, while separately purchased credits do not expire.
+- During beta, **Pro (Beta)** users receive the same Pro-cycle credit allowance without billing while beta access remains active.
+- You can check your balance in **Settings > Credits**.
+- Before any compute is provisioned, you approve a spending cap — no surprises.
+- **User budgets** fund your own managed compute usage.
+- Campaign organizers can also fund participant compute through root-backed campaign budgets.

package/skills/flywheel/compute/managed-compute.md

@@ -0,0 +1,44 @@
+# [](https://flywheel.paradigma.inc//#managed-compute)Managed Compute
+
+Flywheel can provision managed GPU instances for you from providers like Lambda Labs, Modal, Vast.ai, and Prime Intellect — directly from your agent conversation. You don't need to leave your workflow to spin up machines.
+
+## [](https://flywheel.paradigma.inc//#how-it-works)How it works
+
+1. **Ask your agent for compute.** When you need a GPU for an experiment, just say so:
+
+   ```console
+   $ <your-mcp-host> "I need a GPU to train a small transformer on this dataset"
+
+   I'll provision a GPU for this node. First, I need you to approve a budget.
+   Opening the approval page now...
+   ```
+
+2. **Approve a budget.** Flywheel opens an approval page in your browser where you set a spending cap for managed compute acquisition.
+3. **The agent handles the rest.** It acquires a machine, waits for it to become ready, and gets SSH access automatically. Provisioning typically takes a few minutes — the agent polls for readiness in the background.
+4. **Release when done.** When you're finished, the agent releases the lease. You can also release leases from the WebUI at any time.
+
+## [](https://flywheel.paradigma.inc//#managing-machines-in-the-webui)Managing machines in the WebUI
+
+In **Settings > Machines**, you can see all GPU leases across your account — including the provider, state, hourly rate, total spend, and the acquire context that originally launched each lease. You can release individual leases or all at once.
+
+![settings machines view](https://flywheel.paradigma.inc/assets/settings_machines-CJd5Iw8W.png)
+
+Inside a node, the node view focuses on compute policy and budget tracking (spent vs. hard cap). Active machines themselves are managed from the account level **Settings > Machines** view.
+
+## [](https://flywheel.paradigma.inc//#credits-and-billing)Credits and billing
+
+Compute is billed against your Flywheel credits balance, which is separate from your subscription.
+
+- The **Pro subscription** ($20/month or $204/year) includes $10 in non-rollover credits each Pro cycle. Those credits refresh when the plan renews, while separately purchased credits do not expire.
+- During beta, **Pro (Beta)** users receive the same Pro-cycle credit allowance without billing while beta access remains active.
+- You can check your balance in **Settings > Credits**.
+- Before any compute is provisioned, you approve a spending cap — no surprises.
+- **User budgets** fund your own managed compute usage. Campaign organizers can also fund participant compute through root-backed campaign budgets (more on this in the next section).
+
+For a focused reference, see `compute/credits-and-billing.md`.
+
+## [](https://flywheel.paradigma.inc//#tips)Tips
+
+- Provisioning takes a few minutes — the agent polls automatically, so you don't need to babysit it.
+- You can walk away; Flywheel continues while the machine spins up.
+- Release leases when you're done to save credits.

package/skills/flywheel/example-workflows/organizing-exploring-and-iterating-on-a-research-topic.md

@@ -0,0 +1,255 @@
+# Organizing, Exploring, and Iterating on a Research Topic
+
+> The tool lists below are inferred from the current [Flywheel MCP tool map](../reference/flywheel-mcp-tool-map.md). They are likely tool sequences for each step, not verbatim execution logs.
+
+## Image Description
+
+```text
+A square, dark fantasy avatar showing the head and upper chest of a shadowy armored figure. The armor is black-blue with sharp ridges and an ominous, icy sheen, and two bright cyan-blue eyes glow from beneath the helmet. The overall palette is cold and spectral, giving the image a lich-like, menacing look.
+```
+
+## [tensorqt](https://x.com/tensorqt) · [@tensorqt](https://x.com/tensorqt) · [9:23 pm · 12 Mar 2026](https://x.com/tensorqt/status/2032190671281332280)
+
+now, let's talk about how a lich uses Flywheel. let's start with an experiment i've tried last week
+
+### Quote
+
+### Image Description
+
+```text
+A tiny square black avatar with a centered white wireframe cube logo. The cube is drawn with thin clean lines and appears slightly tilted in perspective, like a minimalist 3D box icon floating on a solid black background.
+```
+
+Paradigma · @paradigmainc · 12 Mar
+
+Replying to @paradigmainc
+
+Flywheel views Directed Acyclic Graphs as the underlying data structure for research: nodes can be observations or experiments. When they're experiments, they contain an hypothesis and the artifact of the experiments that may reject it. In Flywheel, researchers can focus on
+
+### Image Description
+
+```text
+A clean Flywheel graph screenshot on a white canvas. Near the upper-right is a black root node labeled `scheduled muon`, connected to a branching network of pale beige and faint pink circular nodes linked by thin gray lines. Over the center sits a floating card labeled `Branch C1: fixed-alpha sw...` with an `EMPIRICAL` badge. The card text says it executed fixed-alpha sweeps on Shakespeare-char, including finer granularity below 0.5 and broad ranges crossing 0.5. Inside the card is a small plot preview titled `ALPHA_REFINE_BELOW_0.5`, showing a downward-sloping blue line with several marked points and a dashed reference line. More graph branches trail down the left side and into the lower-right corner, giving the impression of a research tree with many experiment offshoots.
+```
+
+### Likely Flywheel MCP tools for this step
+
+- `mcp__flywheel__flywheel_stage_node_create` to create the root `scheduled muon` graph.
+- `mcp__flywheel__flywheel_stage_node_update` to describe the overall research question and first branch.
+- `mcp__flywheel__flywheel_branch_node` to split the root into experiment branches.
+- `mcp__flywheel__flywheel_get_node_tree` to inspect the DAG as it starts to fill out.
+- `mcp__flywheel__flywheel_commit_node` to persist the initial structure.
+
+---
+
+### Image Description
+
+```text
+A square, dark fantasy avatar showing the head and upper chest of a shadowy armored figure. The armor is black-blue with sharp ridges and an ominous, icy sheen, and two bright cyan-blue eyes glow from beneath the helmet. The overall palette is cold and spectral, giving the image a lich-like, menacing look.
+```
+
+## [tensorqt](https://x.com/tensorqt) · [@tensorqt](https://x.com/tensorqt) · [12 Mar](https://x.com/tensorqt/status/2032191049431499130)
+
+as you all know, liches are known for obsessing over muon. i make no exception. one thing that always bothered me was how muon was performing this drastic (USV^T )^0 intervention, effectively flattening all singular values.
+
+### Likely Flywheel MCP tools for this step
+
+- `mcp__flywheel__flywheel_branch_node` to open an insight branch for the core muon observation.
+- `mcp__flywheel__flywheel_stage_node_update` to record the singular-value flattening concern as an explicit insight or hypothesis.
+- `mcp__flywheel__flywheel_commit_node` to preserve that observation as a traceable node.
+
+---
+
+### Image Description
+
+```text
+A square, dark fantasy avatar showing the head and upper chest of a shadowy armored figure. The armor is black-blue with sharp ridges and an ominous, icy sheen, and two bright cyan-blue eyes glow from beneath the helmet. The overall palette is cold and spectral, giving the image a lich-like, menacing look.
+```
+
+## [tensorqt](https://x.com/tensorqt) · [@tensorqt](https://x.com/tensorqt) · [12 Mar](https://x.com/tensorqt/status/2032191420103110717)
+
+in my mind, there must have been a "softer" way to interpolate between nesterov momentum sgd and muon, in a way that muon would be the "maximum entropy" version of preconditioning
+
+### Likely Flywheel MCP tools for this step
+
+- `mcp__flywheel__flywheel_branch_node` to fork a new hypothesis branch from the original muon observation.
+- `mcp__flywheel__flywheel_stage_node_update` to capture the "softer interpolation" idea between SGD and muon.
+- `mcp__flywheel__flywheel_commit_node` to save the refined hypothesis before experimenting.
+
+---
+
+### Image Description
+
+```text
+A square, dark fantasy avatar showing the head and upper chest of a shadowy armored figure. The armor is black-blue with sharp ridges and an ominous, icy sheen, and two bright cyan-blue eyes glow from beneath the helmet. The overall palette is cold and spectral, giving the image a lich-like, menacing look.
+```
+
+## [tensorqt](https://x.com/tensorqt) · [@tensorqt](https://x.com/tensorqt) · [12 Mar](https://x.com/tensorqt/status/2032191844122075385)
+
+so, i decided to spin up my MCP host and do a bunch of experiments. as usual, it quickly became a mess of a trillion wandb runs noone could trace anymore.
+
+### Likely Flywheel MCP tools for this step
+
+- `mcp__flywheel__flywheel_stage_node_create` or `mcp__flywheel__flywheel_branch_node` to turn scattered runs into explicit branches instead of an untracked run log.
+- `mcp__flywheel__flywheel_list_nodes` to enumerate existing branches and runs.
+- `mcp__flywheel__flywheel_get_node_tree` to inspect the structure of the experiment graph.
+- `mcp__flywheel__flywheel_commit_node` to keep the graph auditable as new work is added.
+
+---
+
+### Image Description
+
+```text
+A square, dark fantasy avatar showing the head and upper chest of a shadowy armored figure. The armor is black-blue with sharp ridges and an ominous, icy sheen, and two bright cyan-blue eyes glow from beneath the helmet. The overall palette is cold and spectral, giving the image a lich-like, menacing look.
+```
+
+## [tensorqt](https://x.com/tensorqt) · [@tensorqt](https://x.com/tensorqt) · [12 Mar](https://x.com/tensorqt/status/2032192005883773428)
+
+then, [@thelokasiffers](https://x.com/thelokasiffers) released an early version of our MCP integration for the first time. in a few minutes, this is what my experiments looked like:
+
+### Likely Flywheel MCP tools for this step
+
+- `mcp__flywheel__flywheel_stage_node_create` to create the root node if it did not already exist.
+- `mcp__flywheel__flywheel_branch_node` to fan the work into separate experiment branches.
+- `mcp__flywheel__flywheel_get_node_tree` to inspect the resulting DAG layout.
+- `mcp__flywheel__flywheel_summarize_node_tree` to quickly understand branch progress and outcomes.
+- `mcp__flywheel__flywheel_commit_node` to preserve the graph state.
+
+### Image Description
+
+```text
+A tall, narrow node-link graph on a white background. At the upper-left is a solid black node labeled `scheduled muon`, from which a thin gray edge leads into a descending chain of pale beige and soft pink circular nodes. The graph branches intermittently as it moves downward, creating clusters of small leaves around intermediate nodes. The overall structure resembles a research tree or execution DAG, with the black root on the left and the rest of the experiment branches cascading diagonally downward toward the lower-left and middle portions of the image.
+```
+
+---
+
+### Image Description
+
+```text
+A square, dark fantasy avatar showing the head and upper chest of a shadowy armored figure. The armor is black-blue with sharp ridges and an ominous, icy sheen, and two bright cyan-blue eyes glow from beneath the helmet. The overall palette is cold and spectral, giving the image a lich-like, menacing look.
+```
+
+## [tensorqt](https://x.com/tensorqt) · [@tensorqt](https://x.com/tensorqt) · [12 Mar](https://x.com/tensorqt/status/2032193065595584916)
+
+what i did was pretty simple: i started discussing with the models my intuition: NS in muon is about approximating G(G^TG)^(-1/2). what if we could do it so that we could take a fraction power our matrices instead of just the zeroth? so something looking like US^pV^T
+
+### Likely Flywheel MCP tools for this step
+
+- `mcp__flywheel__flywheel_branch_node` to create an insight branch for the `US^pV^T` intuition.
+- `mcp__flywheel__flywheel_stage_node_update` to store the proposed fractional-power formulation.
+- `mcp__flywheel__flywheel_commit_node` to save the idea before turning it into experiments.
+
+---
+
+### Image Description
+
+```text
+A square, dark fantasy avatar showing the head and upper chest of a shadowy armored figure. The armor is black-blue with sharp ridges and an ominous, icy sheen, and two bright cyan-blue eyes glow from beneath the helmet. The overall palette is cold and spectral, giving the image a lich-like, menacing look.
+```
+
+## [tensorqt](https://x.com/tensorqt) · [@tensorqt](https://x.com/tensorqt) · [12 Mar](https://x.com/tensorqt/status/2032195027829477780)
+
+then i realized: if we use NS to have an iteration that approximates powers of -1/2, we could design offline some polinomials that approximated the power of -p
+
+### Likely Flywheel MCP tools for this step
+
+- `mcp__flywheel__flywheel_branch_node` to open a follow-up hypothesis branch around polynomial approximations.
+- `mcp__flywheel__flywheel_stage_node_update` to record the new approximation strategy.
+- `mcp__flywheel__flywheel_commit_node` to preserve the new line of attack.
+
+---
+
+### Image Description
+
+```text
+A square, dark fantasy avatar showing the head and upper chest of a shadowy armored figure. The armor is black-blue with sharp ridges and an ominous, icy sheen, and two bright cyan-blue eyes glow from beneath the helmet. The overall palette is cold and spectral, giving the image a lich-like, menacing look.
+```
+
+## [tensorqt](https://x.com/tensorqt) · [@tensorqt](https://x.com/tensorqt) · [12 Mar](https://x.com/tensorqt/status/2032195494437347721)
+
+at this point i started testing this out, would i get really the right spectra? that's when flywheel kicked in: i asked my MCP host to spin up some instances and train some models. in one of the nodes, we can see us sanity checking, and saving plots as artifacts, that we are indeed interpolating between regular SV distribution and zeroth power
+
+### Likely Flywheel MCP tools for this step
+
+- `mcp__flywheel__flywheel_branch_node` to create the empirical branch for the spectra sanity check.
+- `mcp__flywheel__flywheel_stage_node_update` to record the hypothesis and evaluation criteria.
+- `mcp__flywheel__flywheel_request_budget_approval`, `mcp__flywheel__flywheel_compute_acquire`, `mcp__flywheel__flywheel_compute_status`, and `mcp__flywheel__flywheel_compute_connection` to run the experiments on managed compute.
+- `mcp__flywheel__flywheel_prepare_artifact_publish` to attach the singular-value plot as an artifact.
+- `mcp__flywheel__flywheel_commit_node` to mark the empirical step as completed.
+
+### Image Description
+
+```text
+A wide screenshot of a Flywheel branch details page titled `Branch A2: polynomial alpha sweeps`, with status pills such as `EMPIRICAL`, `COMMITTED`, `COMPLETED`, and `PRIVATE` across the top. In the main content area, a `SUMMARY` section says the run compared practical approximation behavior against exact-SVD references across the same alpha ranges, and notes `Hypothesis verdict: partially confirmed.` Below that is an `ARTIFACTS` panel containing a chart image. The chart title reads approximately `Singular values after polynomial approx (deg 3) of (G^T G)^(-alpha)`. The x-axis is an index over sorted singular values, the y-axis is logarithmic, and many slanted curves stack from dark blue at the top to yellow near the bottom, accompanied by a vertical color bar labeled `Alpha`. On the far right of the screenshot, a miniature map of the experiment tree appears as a vertical chain of diamond-like markers.
+```
+
+---
+
+### Image Description
+
+```text
+A square, dark fantasy avatar showing the head and upper chest of a shadowy armored figure. The armor is black-blue with sharp ridges and an ominous, icy sheen, and two bright cyan-blue eyes glow from beneath the helmet. The overall palette is cold and spectral, giving the image a lich-like, menacing look.
+```
+
+## [tensorqt](https://x.com/tensorqt) · [@tensorqt](https://x.com/tensorqt) · [12 Mar](https://x.com/tensorqt/status/2032196071741395160)
+
+at this point, quite a few things were in question, what would happen if i trained a model to interpolate between sgd and muon with this technique, as if "scheduling" muon?
+
+### Likely Flywheel MCP tools for this step
+
+- `mcp__flywheel__flywheel_branch_node` to fork a new investigation around schedule design.
+- `mcp__flywheel__flywheel_stage_node_update` to record the competing schedule hypotheses.
+- `mcp__flywheel__flywheel_commit_node` to preserve the question before launching more runs.
+
+---
+
+### Image Description
+
+```text
+A square, dark fantasy avatar showing the head and upper chest of a shadowy armored figure. The armor is black-blue with sharp ridges and an ominous, icy sheen, and two bright cyan-blue eyes glow from beneath the helmet. The overall palette is cold and spectral, giving the image a lich-like, menacing look.
+```
+
+## [tensorqt](https://x.com/tensorqt) · [@tensorqt](https://x.com/tensorqt) · [12 Mar](https://x.com/tensorqt/status/2032197957705994659)
+
+but which way should we schedule? not clear. is it sgd first or muon first? how do we schedule? do we change the lr? this usually gets me quickly tangled in a mess of repos / untrackable experiments and lazy search for a gpu to run my stuff on. with flywheel, i simply desxcribe the experiments and my hypotheses as i wanted them, approved a budget, and then watched the model provision the compute, juggle the experiments, and update the graph in real time with the results, while i was thinking of the ideas
+
+### Likely Flywheel MCP tools for this step
+
+- `mcp__flywheel__flywheel_branch_node` to split the root into separate schedule and learning-rate branches.
+- `mcp__flywheel__flywheel_stage_node_update` to encode the hypotheses and sweep definitions.
+- `mcp__flywheel__flywheel_request_budget_approval` and `mcp__flywheel__flywheel_list_budget_grants` to secure spend before launch.
+- `mcp__flywheel__flywheel_compute_acquire`, `mcp__flywheel__flywheel_compute_status`, and `mcp__flywheel__flywheel_compute_connection` to provision GPUs and keep them available to the agent.
+- `mcp__flywheel__flywheel_prepare_artifact_publish` to attach result plots and cards as branches finish.
+- `mcp__flywheel__flywheel_get_node_tree` or `mcp__flywheel__flywheel_list_executions` to monitor the graph as the runs progress.
+- `mcp__flywheel__flywheel_commit_node` to finalize each completed empirical branch.
+
+### Image Description
+
+```text
+A very wide Flywheel canvas view on a bright white background. In the top-left corner is the `Flywheel` wordmark, and just below it are pill-like controls labeled `Free 1` and `Timeline 2`. Near the upper-middle is a black node labeled `scheduled muon`, connected to a diagonal branching graph of pale beige and pink nodes. Floating over the graph is a card titled `Branch C3: entropy-thres...` with an `EMPIRICAL` badge and descriptive text about sweeping entropy-threshold schedule configurations on Shakespeare-char, including follow-up high-threshold variants. Inside the card is a preview bar chart with several vertical bars shaded from greenish teal to light blue. On the far right side of the canvas is another black node labeled `Attention Sink Hypothe...`, implying a separate connected branch or neighboring graph. The interface also includes small icons in the top-right and a large circular `+` button near the bottom-right corner.
+```
+
+### Image Description
+
+```text
+A dark-mode chat screenshot rather than a scientific plot. The interface shows previous conversation sections separated by thin horizontal dividers and labels like `4 previous messages` and `1 previous message`. The visible assistant text says budget approval is required before MCP can allocate compute, asks the user to approve a Flywheel compute budget with a suggested cap of `$5`, and includes a blue link labeled `Approve Flywheel compute budget`. To the right, a rounded dark chat bubble reads `go with a 10$`. Lower in the screenshot, another message asks the user to approve an updated `$10` budget request and shows another blue link labeled `Approve $10 Flywheel compute budget`. A second rounded user bubble near the bottom-right says `good`. The whole image uses a black background with white text and muted gray separators.
+```
+
+---
+
+### Image Description
+
+```text
+A square, dark fantasy avatar showing the head and upper chest of a shadowy armored figure. The armor is black-blue with sharp ridges and an ominous, icy sheen, and two bright cyan-blue eyes glow from beneath the helmet. The overall palette is cold and spectral, giving the image a lich-like, menacing look.
+```
+
+## [tensorqt](https://x.com/tensorqt) · [@tensorqt](https://x.com/tensorqt) · [12 Mar](https://x.com/tensorqt/status/2032198847376630125)
+
+i won't spoil for you how this ends. because this will soon be a public graph in Flywheel. In Flywheel, you can share your graphs with your co-authors and even the public, and anyone can contribute their idea, reproduce the experiment or show that it was all luck
+
+### Likely Flywheel MCP tools for this step
+
+- `mcp__flywheel__flywheel_set_node_access_policy` to share the graph with co-authors or make it public.
+- `mcp__flywheel__flywheel_bulk_set_node_access_policy` to apply the same policy across many branches.
+- `mcp__flywheel__flywheel_get_node_access_policy` to verify that the sharing settings are correct.
+- `mcp__flywheel__flywheel_export_summary` or `mcp__flywheel__flywheel_export_subgraph` to package the graph for outside review or reuse.