Junction pricing is easiest to understand by asking one workflow question: how many local agent sessions and machines do you need to control?
The plans are intentionally simple. Free gives you core app access, one saved daemon connection, and two active or open chats. Junction Core is $10/month and removes those daemon and chat limits. Switchboard is $15/month and adds Linear automation that can turn issues into pull requests through agent runs.
That is the mechanical difference. The more useful question is which plan matches the way you actually use Claude Code and Codex.
The short version
| Plan | Price | Best fit | Main limit or upgrade |
|---|---|---|---|
| Free | $0/month | Trying Junction with one machine and a small number of open sessions | One saved daemon connection and two active/open chats |
| Junction Core | $10/month | Developers using multiple machines or keeping several agent sessions open | Unlimited daemons and open chats |
| Switchboard | $15/month | Teams that want Linear issue-to-pull-request automation | Adds Switchboard automation on top of Core |
If you are still setting up Junction for the first time, start with Free. If you already know you want to connect a laptop and a workstation, or you keep multiple Claude Code and Codex sessions open at once, Core is the practical default. If your team wants tagged Linear issues to become isolated agent runs and pull requests, Switchboard is the plan built for that.
What Free is for
Free is not a fake trial. It is the simplest way to run the core Junction workflow:
- install the daemon,
- pair one machine,
- open the app from a browser or phone,
- start or monitor local agent sessions,
- use the control surface for real-time output, approvals, and review.
The limits are clear: one saved daemon connection and two active or open chats.
That makes Free a good fit when you are validating the workflow on a single laptop or workstation. You can answer the questions that matter before paying:
- Does the daemon pair cleanly?
- Can I see live output from my phone?
- Can I control Claude Code or Codex without moving the repo?
- Do approvals and stop controls feel useful?
- Does this beat leaving a terminal open?
Free is also useful for developers who only need one development machine connected most of the time. If your agent work is occasional, bounded, and does not require multiple parallel sessions, you may not need more.
Where Free starts to feel tight
Free becomes limiting when your workflow stops being "one machine, one or two active threads."
You will likely feel the limit if:
- you run agents on both a laptop and a workstation,
- you keep one long-running investigation open while starting another task,
- you want a headless server or VPS connected as a second daemon,
- you regularly compare Claude Code and Codex on different tasks,
- or you do not want to close old chats just to start new work.
Those are not edge cases. They are the normal shape of serious agent work once the tool becomes part of your development routine.
What Junction Core unlocks
Junction Core is $10/month. It gives you unlimited daemons and unlimited open chats.
That matters because Junction is not a cloud coding workspace. The daemon runs on your machine, and each machine has its own local environment: repos, tools, provider login, GitHub CLI state, model configuration, and runtime constraints.
Core is for the moment you want Junction to become the control panel across that real environment.
A common Core setup looks like this:
- laptop for interactive work,
- workstation for heavier test suites,
- always-on machine for background tasks,
- phone for monitoring and approvals,
- browser for final review.
You can keep Claude Code and Codex workflows separated by machine, project, or task type. You can leave one investigation open while another agent works on a small fix. You can stop one run without losing sight of the others.
The upgrade is not only "more quantity." It is less operational friction.
When Core is the right plan
Choose Core when Junction has moved from experiment to daily workflow.
Good signals:
- You use more than one daemon.
- You have more than two active or open chats often.
- You run agents across multiple repositories.
- You want to keep sessions open for context instead of constantly archiving them.
- You need mobile monitoring for work that continues after you leave the desk.
- You want one control surface for local Claude Code and Codex work instead of several terminal windows.
Core is also the better plan for developers who split work across machines. A local-first control surface is most valuable when the local machines remain distinct. Your laptop might have one repo and set of credentials. A workstation might have another. A server might stay awake when your laptop sleeps. Junction Core gives you room to connect that setup without treating each machine as a separate product experience.
What Switchboard adds
Switchboard is $15/month. It includes Core and adds Linear automation.
The Switchboard workflow is different from a manual chat. Instead of opening an agent session and steering it by hand, Switchboard is for structured issue-to-pull-request automation. A tagged Linear issue can become an agent run with its own isolated worktree, branch, and pull request path.
That is useful when the work is clear enough to delegate:
- small bugs with reproduction steps,
- scoped docs updates,
- maintenance tasks,
- refactors with obvious boundaries,
- test fixes with a known failure,
- implementation work where the Linear issue already contains enough context.
Switchboard is not a substitute for product judgment. It is an automation layer for issues that are already written well enough for an agent to attempt.
If you want the mechanics in more detail, read How Switchboard Turns Linear Issues Into Pull Requests.
When Switchboard is the right plan
Choose Switchboard when the bottleneck is not starting individual agent chats. The bottleneck is turning a queue of well-scoped issues into reviewable pull requests without babysitting every run.
Good signals:
- Your team already uses Linear to define engineering work.
- You have repeated issue types that agents can handle safely.
- You want routing by team, repository, daemon, provider, or model.
- You want runs to happen through a structured workflow instead of ad hoc prompts.
- You care about each automation run having a reviewable branch and pull request.
Switchboard is especially useful when you have enough issue volume that manual session setup becomes the overhead. If the human still has to copy the issue, create a branch, start a prompt, watch the run, and open the PR every time, the automation value is capped. Switchboard moves that repeated setup into the product.
What plan should a solo developer pick?
Start with Free if you are new to Junction. Pair one daemon, run a small Claude Code or Codex task, and see whether the browser and phone control surface fits your day.
Move to Core when you hit either limit naturally: more than one saved daemon or more than two open chats. Do not overthink it. If the limits make you close useful sessions or avoid connecting a second machine, Core is the right plan.
Switchboard is usually unnecessary for a solo developer unless you use Linear heavily and want issue-to-pull-request automation for your own backlog. It can still be valuable, but it solves a different problem from mobile monitoring.
What plan should a team pick?
For a team, the question is less about price and more about process maturity.
Core fits teams that want shared habits around local agent control but still prefer humans to start and steer most sessions. It gives room for multiple daemons, open chats, and machine-specific workflows.
Switchboard fits teams that already know which issues can be delegated. The quality of the Linear issue matters. A vague issue creates a vague agent run. A focused issue with acceptance criteria, relevant files, and test expectations has a much better chance of becoming a reviewable pull request.
If your team is still learning which tasks are safe for agents, begin with Core and manual runs. If you already have a steady stream of well-scoped issues, Switchboard is the more direct fit.
Tradeoffs to be honest about
Free is generous enough to test the workflow, but it is not meant to model a multi-machine setup. If you are evaluating Junction for several developers or multiple always-on daemons, Core gives you a more realistic view.
Core gives you more control surface capacity, but it does not automate issue intake. You still decide when to start sessions, what to ask, and how to review the result.
Switchboard automates a structured workflow, but only well-scoped issues deserve automation. It is not a way to turn unclear product requests into clean pull requests by magic. The issue still needs context, constraints, and review.
A practical decision rule
Use this rule:
- Pick Free to try Junction on one machine.
- Pick Core when the daemon or chat limits interrupt real work.
- Pick Switchboard when Linear issues should become agent runs and pull requests.
That is the simplest way to avoid buying too early or waiting too long.
If you are still setting up the daemon, start with the Junction setup guide. If you are choosing a plan now, compare the current limits and prices on Junction pricing.