How to Structure One Junction Account for a Small Team

Small Teams Need Fewer Surprises

A small team does not need a complicated AI agent platform on day one. It needs a clean way to see what Claude Code and Codex are doing, where they are running, who owns the review, and which machine is allowed to touch which repository.

Junction""'s local-first model fits that shape: daemons run on your machines, agents execute where the code lives, and the browser becomes the control surface. The team structure still matters. Without clear ownership, one account can become a confusing pile of machines, sessions, and half-reviewed branches.

Start With Ownership

For each daemon, assign an owner:

• Who maintains the machine?
• Who controls provider authentication?
• Which repositories can run there?
• Who reviews work produced there?
• Is the daemon allowed for Switchboard?

Ownership does not have to mean only one person can use it. It means one person is accountable for the daemon being sane.

Pick A Simple First Topology

A practical small-team setup usually starts with:

one team workstation or VPS for shared low-risk tasks
one or two developer laptops for interactive work
one repository used as the first automation candidate

Do not connect every machine and every repo immediately. Prove the workflow with a small slice.

The shared daemon should have clean GitHub authentication, the right agent provider logins, and only the repositories it is expected to work on. Developer laptops can keep interactive or exploratory sessions.

Match Plans To Workflow Shape

Junction Free includes core app access, one saved daemon connection, and two open chats. That can be enough for a founder or a single developer proving the workflow.

Core is the better fit when a small team needs unlimited daemons and open chats. That usually happens as soon as a team wants a shared daemon plus personal development machines.

Switchboard is the right tier when the team wants Linear automation: tagged issues becoming agent runs and pull requests through configured routes.

Do not buy automation before the team has a review habit. Switchboard should build on a workflow that already knows how to scope issues and review agent diffs.

Keep Provider Auth Boring

Claude Code and Codex handle their own authentication. Junction should not become a place where team members blur personal and work credentials.

Small-team rules:

• Work daemons use work-approved provider accounts.
• Personal daemons do not run company repos.
• GitHub CLI identity is checked before PR work.
• Shared machines have documented owners.
• Secret-bearing repos run only on approved daemons.

These rules prevent confusing PR authorship, wrong remotes, and unclear access boundaries.

Define Review Responsibility

Every agent-created branch needs a human review owner. Decide this before automation.

For manual runs, the person who starts the run usually owns the review. For Switchboard runs, ownership can come from the Linear issue, the repo owner, or a team rotation. What matters is that a PR does not appear with nobody responsible.

A good small-team default:

The person who marks an issue ready for agent automation owns first review unless another reviewer is assigned.

That rule keeps automation from becoming anonymous work.

A Good First Team Workflow

1. Set up one shared daemon.
2. Connect one low-risk repository.
3. Run Claude Code or Codex manually through Junction.
4. Review the diff as a team.
5. Write down the issue shape that worked.
6. Add a second daemon or open chat only when needed.
7. Introduce Switchboard after manual runs are predictable.

This sequence prevents the team from debugging account structure, automation routing, provider auth, and review habits all at once.

Tradeoffs

Small teams move fast, so process can feel annoying. But AI agent work creates more parallel state than normal pair programming. Without a little structure, the team loses track of what is running, what is safe to approve, and what needs review.

The goal is not heavy governance. It is enough structure that the work is legible the next morning.

Where Junction Fits

Junction gives the team one control surface for local agent runs: live output, approvals, diffs, Git state, push notifications, and multiple daemons on paid plans. The team still decides the operating rules.

If you are choosing a plan, use the pricing page. If you are setting up the first daemon, start with the setup guide. For auth boundaries, read Keep Claude Code and Codex Auth Separate on Each Daemon.