Stop being the copy-paste
between your AI agents.

Claude Code writes, Codex reviews, and you ferry context between three terminals. Autumn wires your agents into one live canvas. One prompt in, the whole team runs, and real code lands on your drive.

Bring the agents and models you already use

  • Claude Code
  • Codex
  • Antigravity
  • Gemini
  • OpenRouter
  • groq
  • Hugging Face
  • GitHub Copilot
  • Windsurf
  • Mistral AI
  • Ollama
  • Perplexity
  • GitHub
  • Replit

Every agent, every handoff. On one screen.

Autumn · Build an XO game, test it, push to GitHub
The Autumn canvas running an XO game build. The agent toolbox sits on the left. On the canvas, a Project Manager agent hands a task plan to Claude Code CLI and Antigravity; Claude Code passes its source code to Codex for review, which is still working; Antigravity shows an error because GITHUB_TOKEN is not set; a QA and security tester waits for both. A prompt bar at the bottom asks Autumn AI to update the workflow.

Each agent is a node with its status, output and logs visible at a glance. Context moves along the wires.

Meet Autumn

Three terminals. Zero shared context.

Other tools make you copy output from one chat window into the next, babysit three terminals, and rebuild context every time a session hits its limit.

With Autumn you describe the outcome once. It plans a graph of agents, connects them and runs them in order. Every agent starts with the work that came before it.

One prompt, a whole agent team. Real code, written to your drive.
14specialist agents, from Claude Code to launch strategist, plus your own custom agent
1prompt to generate the whole agentic workflow
3LLM providers with automatic failover
5views: Canvas, Kanban, IDE, Brain, Launch

An agentic workflow you can actually see

No automations to configure, no YAML, no node-by-node prompt wiring. Describe the goal and edit the graph by talking to it.

New workflow
The goal “Build an XO game, test it, and push it to GitHub” typed into Autumn’s prompt bar, above the agent graph it produced: a project manager, Claude Code, Codex, Antigravity and a QA tester, wired together.

Message one goal, get a whole team

“Build an XO game, test it, push to GitHub.” Autumn turns a plain-language goal into a graph of specialist agents with roles and deliverables. Say “add a QA tester node” to change it.

Claude Code → Codex
Two terminal nodes on the Autumn canvas. Claude Code CLI has written three files for the XO game; a dashed wire labelled Source code carries them to Codex Code Generator, whose terminal shows it reviewing the files.

Claude Code and Codex, connected

Terminal agents are first-class nodes. Claude Code writes, Codex reviews, Antigravity runs autonomous tasks, and each one sees the others’ full output. No copy-paste in between.

Run status
Three agent nodes in three states: Claude Code CLI completed with a green outline, Codex Code Generator still working with an amber glow, and Antigravity in red with the error “GITHUB_TOKEN not set” in its terminal.

See who’s done, who’s stuck

Every node shows idle, working, completed or error, with streaming output and a mini terminal. Timeline replay turns a failed run into something you can read, not reconstruct.

Launch chain
A launch chain on the Autumn canvas: market research, strategy and copywriter agents feed a FLUX image agent with the poster “Lose a game, learn a move.”, a Wan video agent rendering the teaser, and a launch campaign agent waiting its turn.

From build to launch in one chain

Research, strategy, brand, copy, poster, video, launch plan. Image (FLUX) and video (Wan) agents share the same brief, so your launch assets match your positioning.

Context that travels

Each agent gets the full output of the agents wired into it, plus a summary of everything else that finished.

Provider failover

LLM calls fail over from OpenRouter to Gemini to Groq automatically when one stalls.

Timeline replay

Scrub through a run and read every handoff and per-connection log after the fact.

Your keys, your models

Bring your own API keys. State lives on the canvas, not in a chat session that expires.

How it works

One prompt. Real code, written to your drive.

1

Describe the outcome

Write the goal the way you’d brief a teammate. Attach a reference file if you have one.

2

Autumn wires the agents

A graph of agents appears on the canvas, each with a role, a deliverable and its upstream inputs.

3

Run, watch, ship

Agents run in dependency order, stream their output, and save deliverables to your workspace.

Why Autumn

Not another chat window. Not tmux.

You can already run agents in terminal tabs, chat windows or workflow builders. Here’s what changes when they share one canvas.

Autumn compared with terminal tabs, chat windows and generic workflow builders
What you needAutumnTerminal tabs / tmuxChat windowsWorkflow builders
See every agent’s status at once● Live node status + logs○ Check each pane○ One chat at a time◐ Run history
Agents pass context to each other● Automatic, along wires○ You copy-paste○ You copy-paste◐ Manual field mapping
Claude Code + Codex in one flow● Both are nodes◐ Side by side, unaware○○ Not built for CLI agents
Build the workflow from a sentence● One prompt○○○ Drag and configure
Survives a provider limit● Failover + canvas state○ Session lost○ Start over◐ Retries
Launch assets, not just code● Copy, poster, video, plan○◐ Separately◐ With plugins
FAQ

The problems builders keep posting about.

We went through what builders post on r/ClaudeCode, r/vibecoding and r/SaaS about running AI coding agents. These are the recurring questions, with straight answers.

What is Autumn?

Autumn is a visual multi-agent canvas for agent orchestration. You describe a goal, and Autumn builds a graph of AI agents (Claude Code, Codex, Antigravity, plus research, strategy, branding, copy, image, video and launch agents), connects them, and runs them in order. Each agent passes its output downstream as context.

How do I run Claude Code and Codex together without copy-pasting between them?
“I’m the human message bus between Claude and Codex.”

Put both on the Autumn canvas as nodes and wire them. Claude Code’s output becomes Codex’s input automatically, so Codex reviews exactly what Claude wrote. Give the reviewer a strict deliverable, such as “list blocking bugs with file and line,” and you approve the result instead of relaying it.

How can I see which AI agent is done, stuck or still working?
“tmux hell: no idea which agent is done or stuck.”

Every node on the canvas shows its live status (idle, ready, working, completed or error), its streaming output and a mini terminal. A minimap and timeline replay show the whole run, and per-connection logs show what moved between agents.

How do I stop parallel coding agents from overwriting each other’s files?
“My agents keep overwriting each other’s files.”

Give each agent one narrow job and the files it owns, and make the downstream agent build on the upstream output instead of editing in parallel. Autumn makes this the default shape: every node has a defined role and deliverable, runs in dependency order, and shows its output before the next step starts.

What happens when Claude Code hits its usage limit mid-task?
“I want to use Codex without losing context until Claude is available again.”

In Autumn the plan, the decisions and each agent’s output live on the canvas, not in one chat session. When one agent hits its limit, another node, such as Codex or Antigravity, can pick up from the same upstream context. LLM calls also fail over automatically from OpenRouter to Gemini to Groq.

Aren’t multi-agent pipelines worse than one good prompt?
“My 5-agent pipeline was slower, more expensive and blander than one prompt.”

They often are, when handoffs are lossy and nobody can see them. Autumn passes the full output of directly wired agents rather than a summary, and makes every handoff inspectable. The rule we recommend: only add an agent when its output is checkable, and keep simple jobs to one node.

Can a solo founder make a launch video and assets without $1,000+ quotes?
“Quotes of $12–15k for a 40-second launch video.”

Autumn chains research → positioning → copy → poster (FLUX) → video (Wan) → launch plan, so every asset comes from the same brief and matches. For a demo video, pair it with a real screen recording and captions. A short clip of the actual product beats generic footage.

How do I keep AI agent costs under control?
“Woke up to a $2,100 bill from a looping agent.”

Autumn runs on your own API keys, so set hard monthly limits in each provider dashboard and use a separate key per project. Runs are a finite graph executed once in dependency order, not an open-ended loop. Per-run budget caps and per-node cost tracking are not in the beta yet.

Is it safe to let agents run shell commands?

The beta runs locally on your own machine with your own keys. Treat terminal agents like any CLI agent: point them at a dedicated project folder, keep backups or git, and review output before you ship it. Sandboxed execution for terminal nodes is not in the beta yet.

Who is Autumn for?

Solo founders, indie hackers and small teams who build with AI coding agents and want one place to orchestrate them, from the first line of code to the launch post.

How much does Autumn cost?

Autumn is free during the private beta. You bring your own model API keys (OpenRouter, OpenAI, Gemini, Groq). Join the waitlist to get access.

Try Autumn this season

We’re onboarding builders in small batches. Join the waitlist and we’ll email you when your spot in the next batch opens.

Join the waitlist

Get access with the next beta batch, plus early build notes.

One email when your spot opens. Unsubscribe anytime.

You’re on the list.

We’ll email you when your beta spot opens.