Documentation
Features

Plans

A plan in SageOx is the plan of record for work your team executes: a design mockup, a go-to-market strategy, a rollout sequence, an engineering change. It is a rich, visual page, not a wall of text. Your AI coworker authors it, you review it, and your coworkers act on it.

A rendered SageOx plan page: a ten-minute summary, cited badges, and the reasoning that shaped the change.
A rendered plan in SageOx: a decide-in-ten-minutes summary, badges cited to real artifacts, and the reasoning that shaped the change, enriched from your Team Context.

Every plan is stored in a repository's Ledger, enriched from your Team Context, and built to be decided on in ten minutes. When the plan shapes code, it stays linked to the pull request it produced, so the reasoning behind a change is never lost.

A plan's subject is anything your team must execute. Where it is authored is narrower: today you write plans inside an AI coworker session (Claude Code or Codex) in a repository set up with SageOx (ox init), with the ox CLI installed. The repository is where the plan is stored, not what the plan has to be about.

You prompt, your coworker authors

You ask your AI coworker for a plan, and it picks the right visuals, writes the page, and saves and renders it for you, running the ox CLI on your behalf.

You sayYour coworker does
"Plan the retry migration. Make it a visual plan and render it."Authors a page, saves it to your repository's Ledger, opens it for review
"Ground it in real data and flag conflicts with our ADRs."Reads live SageOx Team Context, adds cited badges, surfaces collisions
"Tighten the risks section."Revises the same page

Prompts that produce great plans

A bare "make a plan" gets a bare plan. Give your coworker three things: the decision, the audience, and real grounding:

Minimum

Claude Code>Plan the speaker-rematch work. Make it a SageOx enriched visual plan, save it, render it for review.

Good, names the decision and the reader

Claude Code>Design X as a visual plan for a principal engineer with 10 minutes who must decide go / no-go. Lead with the conclusion and the biggest risk.

Best, grounds it in real data and SageOx Team Context

Claude Code>Design the speaker-rematch work as a visual plan for a principal engineer deciding go / no-go: run it against a real recording from our data, enrich it against our SageOx Team Context, and add cited badges for any collisions or conflicting ADRs.

Not only code. The same three things make a non-engineering plan land:

Claude Code>Plan the launch of the new pricing page as a visual plan for the team executing it: the sequence week by week, who owns each step, what we announce where, and the two decisions we need before we start.

Every cited badge points at a real artifact: an ADR, a decision, a teammate's live edit. A plan never puts words in a coworker's mouth; when the evidence is thin, it degrades to a nudge to consult the right person.

Review and iterate

Read the rendered plan, then tell your coworker what to change: it revises the same page, so nothing forks. When the work becomes a pull request, the plan is linked from it, and the review conversation happens there alongside the diff.

Coming soon: clicking an element on a shared plan to leave an anchored comment your coworker acts on. Today, review happens on the rendered page and in the linked PR.

Find plans in the web app

In the SageOx web app, open your team and choose Plans in the left nav. Every plan saved for the team shows up there, newest first. Open any plan to read the full page and share it with a coworker.

Solo? Plans still pay off

You don't need a human team. A coworker is any team member: human or AI. As a team of one, your coworker authors a plan you review in ten minutes instead of a text wall, several coworkers can co-author the same page, and your Ledger accrues durable, searchable plans so a later reader inherits the why.

When work lands, the pull request carries a credit line linking the session and the plan that produced it. Open a PR months later and jump straight to the plan that shaped it, the reasoning travels with the code.

See real examples

Two public plans from the SageOx team, open them to see different visual forms doing real work.

A sequencing plan, a phase-by-phase timeline, with live collision and conflict badges cited to a real file and a tracked issue.

Screenshot to captureA sequencing plan, phase-by-phase timeline with collision and conflict badges cited to a real file and a tracked issue. Sign in to open the full page.

An architecture plan, a dependency graph plus an ownership table with a candid "deliberately excluded" column.

Screenshot to captureAn architecture plan, a dependency graph plus an ownership table with a candid 'deliberately excluded' column. Sign in to open the full page.

More curated examples are coming to the SageOx public team.

What's next