podiumFI

Apache 2.0 · Eight supported coding agents

Every agent takes the same stage.
You conduct the plan.

podiumFI runs Claude Code, Codex and six more agents for you from a single desk — in plain sight, and nothing builds until you approve the plan.

macOS and Linux · one binary
curl -fsSL https://podiumfi.fun/install.sh | sh

Say what you want built. podiumFI reads your repo first, asks about anything still vague, and hands back a plan of tasks you can rewrite. Each change works on its own branch, and you read the diff before anything merges.

Try the planner below ↓

No Node.js needed on macOS and Linux · Windows installs with npm · no extra API key if you already run a coding agent

goal
audit sign-in flow● claudeDONE ✓
refactor sessions● codexDONE ✓
refresh the docs● claudeDONE ✓
harden middleware● codexDONE ✓
fix flaky tests● opencodeDONE ✓
integration pass● claudeDONE ✓
Add rate limiting to the public API
Should the limiter reuse your Redis connection?
Yes, reuse it▌

01

Say what you want

podiumFI reads your repo and asks about anything you left open — before a single task exists.

Add a token-bucket limiterClaude Code · Sonnet 4.5
Answer with 429 and Retry-AfterCodex · GPT-5.2 Codex
Test the limitsOpenCode · DeepSeek V4 Flash

02

Arrange the plan

Swap any task, agent or model before anything runs. The plan is a draft, not a contract.

3 of 3 tasks done

src/rateLimit.js+84
src/server.js+12 −3
test/rateLimit.test.js+96

03

Read the diff, then merge

Change tasks work side by side on their own branches. Yours waits for you at the end.

Interactive planner

Feel how a goal becomes a plan.

Type a goal, rearrange who does what, then approve and watch the run.

Plan a goal

podiumFI would read your repo and ask one clarifying question first. Here, pick a goal (or write your own) and generate the draft plan.

Generate a plan to begin. Build tasks stay parked until you approve.

How it works

You see the plan before any build task starts.

Every task is written out with the agent, model and effort that will run it. You can change any of it first.

01 · Plan

It reads, then asks

The planner reads your repo without changing it, asks about anything unclear, and writes the plan: ordered tasks, each naming the agent and model that will run it.

02 · Run

Many agents, one plan

Each change task gets its own branch and worktree. Independent tasks run at the same time. A dependent task waits until its inputs land on the run's integration branch.

03 · Verify

Done means reported

A task is done when its agent reports completion through podiumFI's own tools, or when a script's exit status says so. No second model judges the work. A task that never reports fails where you can see it.

Why it's different

Four things podiumFI does on purpose.

APPROVAL

Build tasks wait for you

The plan is yours to rewrite before anything builds: prompts, agent, model, effort, mode and dependencies.

EVIDENCE

Done means reported

No second model is asked whether the work looks done. The agent's own completion report decides, and a script's exit status decides for scripts.

MIXED CAST

Several agents, one plan

Eight supported agents can share a plan. Each task picks its agent, model, effort and mode — and a task can move to another agent mid-flight.

LIMITS

Limits pause work, they don't end it

A task that hits its agent's usage limit pauses and resumes in its saved session when the limit resets. Move a paused task to another agent and its unfinished work comes with it.

Supported agents

Eight runners. Bring the ones you already pay for.

podiumFI doesn't sell you another model subscription. It drives the coding agents already installed on your machine, each with its own login, its own models and its own usage limits. Mix them in one plan, per task.

RUNNER · DEFAULT PLANNER

Claude Code

Anthropic's terminal agent. Sonnet and Haiku families, high / medium / low effort. claude on your PATH is enough — podiumFI plans and runs through it with no extra key.

RUNNER

Codex

OpenAI's coding agent. Strong on self-contained refactors and test repair. codex signed in once, then available to every plan.

RUNNER

OpenCode

Open-source runner with the widest model catalog — DeepSeek, Qwen, GLM, Kimi and more via OpenRouter or a local endpoint.

RUNNER

Gemini CLI

Google's agent for long-context research tasks: whole-repo audits, doc sweeps and migration inventories.

RUNNER

Aider

Pair-programming veteran. Good fit for small, tightly-scoped edits on a branch you watch closely.

RUNNER

Cursor Agent

Drives Cursor's agent from the plan when your team already lives in the editor. Tasks land as branches, not chat threads.

RUNNER

Goose

Block's open-source agent, extensible with MCP tools. Picks up your Goose extensions inside podiumFI tasks unchanged.

RUNNER

Amp

Sourcegraph's agent for fast, parallel exploration. Useful as the research leg before a heavier model builds.

Detection is automatic — and honest

On first run podiumFI scans for installed agents and lists only the ones it can actually start. A runner that isn't signed in, or whose binary is missing, never appears in a plan's picker — so a task can't be assigned to an agent that will fail at launch. Add an agent later and run /runners (terminal) or refresh the panel (editor); it joins the cast without restarting the plan.

Inside a plan

Every task carries its full assignment.

Nothing about a task is implied. Before you approve, each card spells out exactly what will run, where, and in what order — and every field is editable.

  • PROMPTThe instruction, in plain wordsGenerated from your goal and the planner's research. Rewrite any line; the runner gets your version, not the draft.
  • RUNNER + MODEL + EFFORTWho does it, and how hard they thinkPicked per task from that runner's real catalog. A rename doesn't need high effort; a data migration does.
  • MODEWhat the runner is allowed to touchBuild edits files and runs commands. Research is read-only. Manual tasks are never given to an agent at all — they're yours.
  • DEPENDS ONThe ordering, made explicitIndependent tasks run in parallel on separate worktrees. A dependent task starts only when its inputs are on the integration branch.
  • SKILLSYour team's habits, attached by nameBuilt-in or repo skills the planner matched to the task. Shown on the card before approval — remove one and it doesn't run.
  • BRANCHOne branch per changeEvery build task works in its own worktree and branch, so two agents never write the same file at the same time.

Editor extension

The whole loop, beside your code.

Live thinking, every research step, and the plan itself, pinned above the composer in VS Code, Cursor and compatible editors.

INSTALL

bash
code --install-extension podium.podium

Or search podiumFI in the Extensions view. The extension bundles its own core, so there is nothing to install from npm.

FIRST RUN

  1. Open a project folder.
  2. Open the podiumFI panel from the activity bar.
  3. Type a goal. Build tasks wait until you approve the plan.

Choose an installed coding agent to plan for you — read only, using its own credentials.

Model names and interface details may change between releases.

▾ CONVERSATIONClaude Code · 3 runners
Add rate limiting to the public API

› Listed a directory, read 2 files, searched the code

The limiter fits between requestId() and auth(), and nothing sets rate-limit headers yet.

Question: should limits apply per API key, or per client IP?

My recommendation: per key, with an IP fallback for anonymous routes.
Per key, with the IP fallback for anonymous traffic

The conversation

Your goal, the research folded into one line you can open, and the question the planner asked before it planned.

▾ PLAN · 5 tasksSupervisor: Watch
1 · Add a token-bucket limiterclaude-code · Claude Sonnet 4.5 · high
2 · Mount it before auth()claude-code · Claude Haiku 4.5
3 · Return 429s with rate-limit headersopencode · DeepSeek V4 Flash
4 · Cover burst traffic in testscodex · GPT-5.2 Codex · medium
5 · Roll out behind a flag MANUALyours to run

Planner ctx 38k (19%) · Claude 5h 23% used · Weekly 41% used

The plan

Docked above the composer. Each task names its runner and model before you press Execute Plan. The footer shows the planner's context and your account's limits.

OpenCode⌄
DeepSeek V4 Flash · openrouter⌄
Build: edit files and run commands⌄

Move a task to another agent

Switch a task's runner and its model, effort and mode follow — picked from what that agent actually offers. An assignment that couldn't start never gets saved.

DeepSeek V4 Flash · openrouter▴
DeepSeek V4 Flashopenrouter
Qwen3 Coder Nextopenrouter
GLM-5openrouter
Kimi K3openrouter

Only models that runner can start

The picker lists the selected runner's own catalog, so you never type an id that only fails once the task starts.

Thinking effort is per task too

The levels offered are the ones that model actually has. A docs task doesn't need to think as hard as a migration — and you decide which is which.

Skills your whole team shares

Write down how your team works once, as a skill in your repo. The planner attaches it to the tasks it fits, and you see it on every task card. /grilling, /to-spec and /tdd come built in.

Terminal UI

The same loop in your terminal, over SSH.

Conversation on the left, live plan on the right. Single keys drive the plan: no menus, no mouse.

INSTALL

bash
curl -fsSL https://podiumfi.fun/install.sh | sh
podium   # in your project

One binary, no Node.js on macOS and Linux. On Windows, or if you prefer npm, run npm install -g podium.

FIRST RUN

  1. Open a project directory in a terminal.
  2. Run podium. The opening screen names the planner and the runners it found.
  3. Type a goal. Build tasks wait until you approve the plan.

An installed coding agent plans by default, with no API key. Change it in place with /planner and /runners.

The planner conversation and the live plan, side by side. Guarded is the default autonomy level.

tab swap chat and plan
f start selected task
E run the whole plan
R change runner
o change model
M execution mode

Autonomy & supervision

You decide how far it goes without you.

Three supervision levels, set per plan — and changeable mid-run. Guarded is the default, and no level ever merges to your branch without a handoff you accept.

DEFAULT

Guarded

podiumFI pauses at every checkpoint that matters.

  • Plan approved by you before anything builds
  • Checkpoints on risky tasks — migrations, deletions, dependency changes
  • Diff review before merge, always

SUPERVISOR

Watch

The plan runs end to end while a supervisor keeps an eye on the stream.

  • No per-task pauses; checkpoints collapse into one review at the end
  • Supervisor flags stalls, loops and off-plan edits as they happen
  • You can grab any running task and take it over

HANDS-OFF

Autopilot

For plans you've run before and trust: overnight batches, codemod sweeps, test repair.

  • Runs to completion or to a stated stop condition
  • Failed tasks retry once, then park with a full report
  • Merge still waits for your handoff — autopilot never pushes

When a limit hits

  • Usage cap reached — the task pauses in its saved session, not in a failed state.
  • Limit resets — the same session resumes where it stopped, context intact.
  • Can't wait? — reassign the paused task to another runner; its brief and progress travel with it.
  • Budget guard — set a per-plan token or time ceiling and podiumFI stops starting new tasks when it's reached.

When something goes wrong

  • Agent goes silent — no completion report means not done. The task fails visibly, with its branch preserved.
  • Tests fail — the failure output is attached to the task card, not buried in a log.
  • Off-plan edit — a runner touching files outside its brief is flagged by the supervisor before merge.
  • You disagree — discard one task's branch without touching the rest of the plan.

Skills

How your team works, written down once.

A skill is a short file in your repo that tells the planner how a kind of task should be done here — your conventions, your checks, your order of operations. The planner attaches skills to the tasks they fit, and you see each attachment before approval.

/grilling

Interrogate the goal before planning: surfaces hidden constraints, edge cases and the questions a senior engineer would ask first.

/to-spec

Turns a loose goal into a written spec — scope, non-goals, acceptance checks — that the plan is then built against.

/tdd

Tests first, then the change, then the refactor. The task isn't done until the new tests pass and the old ones still do.

/review

A second pass over a finished task's diff: correctness, naming, dead code, and anything the brief asked for that's missing.

/verify

Runs the project's own checks — test suite, linter, typecheck, build — and attaches the real output to the task.

/debug

Reproduce first, form a hypothesis, instrument, then fix. No speculative patches stacked on a guess.

WRITE YOUR OWN

.podium/skills/api-change.md
# API change
When a task changes a public endpoint:
1. Update the OpenAPI spec first.
2. Add a contract test for the old shape.
3. Note it in CHANGELOG.md, Unreleased.

HOW IT TRAVELS

  1. Drop a Markdown file in .podium/skills/ and commit it.
  2. Every teammate's podiumFI picks it up on the next plan — no plugin, no install.
  3. The planner suggests it where it fits; you confirm on the task card.

Skills are instructions to the planner, not code that executes. They shape prompts and checks — they never grant a runner new permissions.

Workflows

Three plans, end to end.

The same loop — goal, questions, plan, branches, diff — shaped by three very different kinds of work.

GOAL

Ship a feature

“Add rate limiting to the public API”

  1. Research — planner maps the middleware chain and finds the shared Redis client.
  2. One question — reuse that connection, or open a new one?
  3. 5 tasks, 3 runners — limiter, wiring and 429 contract in parallel; tests depend on all three.
  4. Handoff — one combined diff, 429 behaviour behind a flag you flip.

GOAL

Kill a flaky test

“Checkout suite fails 1 run in 5 — find out why”

  1. Reproduce — a research task runs the suite in a loop and captures the failing seed.
  2. Hypothesis — planner attributes it to a shared fixture, asks you to confirm the scope.
  3. Fix + proof — one build task isolates the fixture; a verify task runs the suite 20× clean.
  4. Handoff — diff shows the fixture change and nothing else.

GOAL

Migrate without downtime

“Move sessions from cookies to Redis”

  1. Inventory — every read and write of the session cookie, across services.
  2. Checkpoint — Guarded mode pauses before the dual-write task for your sign-off.
  3. Staged tasks — dual-write, backfill (manual — yours to run), cut-over behind a flag.
  4. Handoff — rollback is one task branch you simply don't merge.

CLI

For a pipeline instead of a person.

bash
# plan on an agent you already have, no API key
export AI_PROVIDER="claude-code"        # or codex, opencode and five more

podium plan --goal "Add rate limiting to the public API"
podium task-model 3 sonnet            # change a task before it runs
podium run
podium handoff review                 # read the diff first
podium handoff merge                  # then bring it onto your branch
CommandWhat it doesNotes
podium plan --goal "…"Research the repo and draft a plan without running anythingExits 0 with the plan on stdout as JSON with --json
podium task-runner N agentReassign task N to another runnerModel and effort reset to that runner's sane defaults
podium task-model N modelChange one task's model before it runsOnly models that runner can start are accepted
podium task-mode N modeSet a task to build, research or manualManual tasks are skipped by run and left for you
podium runExecute the approved planParallel where dependencies allow; streams status lines
podium statusShow every task's state, branch and last reportSafe to run from a second terminal mid-run
podium resumeResume paused tasks — after a limit reset or a Ctrl-CSessions are restored, not restarted
podium handoff reviewPrint the combined diff of all finished task branchesPer-task diffs with --task N
podium handoff mergeMerge finished branches onto yours, in plan orderStops on the first conflict and leaves the rest untouched
podium discard NThrow away one task's branch and mark it discardedThe rest of the plan is unaffected

PROJECT CONFIG

podium.toml
planner = "claude-code"
autonomy = "guarded"

[runners]
default  = "claude-code"
research = "opencode"

[limits]
max_parallel = 3
pause_on_usage_limit = true

COMMIT IT

  1. One file, repo root. podium.toml sets the planner, default runners, autonomy level and limits for everyone on the project.
  2. Personal overrides stay personal. ~/.config/podium/config.toml wins for your machine only — swap in your own runner without touching the team's file.
  3. Pipelines override both. Environment variables like AI_PROVIDER take precedence for a single run.

Exit codes: 0 = plan complete, 1 = a task failed or never reported, 2 = plan not approved. CI can gate on them directly.

FAQ

Questions, answered straight.

Do I need an API key?

No — not if you already run a coding agent. podiumFI plans and runs through your installed agents using their own sign-in, so there is no extra key to buy or paste. If you'd rather plan on a direct API provider, set AI_PROVIDER and that provider's key instead.

What does podiumFI cost?

podiumFI itself is free and open source under Apache 2.0. You pay only for the agents and models you already use, under your own subscriptions and limits — podiumFI adds no markup and holds no billing relationship with you.

Which agents are supported?

Eight: Claude Code, Codex, OpenCode, Gemini CLI, Aider, Cursor Agent, Goose and Amp. A plan can mix any of them per task, and only agents podiumFI can actually start on your machine appear as options.

Does my code leave my machine?

podiumFI runs locally and sends nothing anywhere itself. Each task runs inside the agent you assigned, so your code goes wherever that agent already sends it — under that agent's own terms, with your own account.

What happens when an agent hits its usage limit?

The task pauses in its saved session instead of failing. When the limit resets, it resumes with context intact — or you reassign it to another runner and the unfinished work moves with it.

Do I need git?

No. Without git, tasks work directly in the folder, one at a time. With git 2.38 or newer you get the full model: a worktree and branch per task, parallel runs, and Merge all at handoff.

Can two tasks edit the same file?

Not at the same time. Each build task works in its own worktree; if two tasks genuinely need the same file, the planner makes one depend on the other so the edits land in order on the integration branch.

How is "done" decided?

By evidence, not vibes: the runner reports completion through podiumFI's own tools, or a check script's exit status says so. No second model grades the work. A task that never reports is shown as failed, with its branch preserved for inspection.

Can I use it in CI?

Yes — that's what the CLI is for. Draft with podium plan, execute with podium run, and gate on the exit code: 0 complete, 1 a task failed, 2 the plan was never approved. Guarded mode's checkpoints become a required --approve flag in pipelines.

Windows?

Supported via npm: npm install -g podium. The terminal UI, CLI and editor extension all work; the one-binary installer is macOS and Linux only.

Troubleshooting, quickly

A runner is missing from the picker — it isn't installed or isn't signed in; podiumFI only lists runners it can start. A task is stuck on RUNNING — check podium status; a runner that never reports is failed visibly, never silently. Merge stops halfway — the first conflicting branch halted the handoff; resolve it, then re-run podium handoff merge and the remaining branches continue in plan order.

Get started

One install, one goal.

Terminal

One binary

bash
curl -fsSL https://podiumfi.fun/install.sh | sh

Installs to ~/.local/bin on macOS and Linux, with no Node.js. Then run podium in your project. On Windows, use npm install -g podium.

Editor

The extension

bash
code --install-extension podium.podium

Or search podiumFI in the Extensions view. It bundles its own core, so there is nothing to install from npm.

What you need

  • One coding agent, installed and signed in: Claude Code, Codex or one of six more. It runs tasks — and it can plan too.
  • No Node.js on macOS and Linux: the terminal UI and CLI are one binary. Windows installs with npm. The editor extension needs only your editor.
  • git is optional. Without git, every task works directly in the folder. With git 2.38 or newer, each task gets its own worktree, delegated tasks and Merge all.

Pre-1.0 software can change between minor releases, so read the changelog before you upgrade.