Account pinning
Multiple Claude Code accounts on one Mac — no logging out.
lpm pins a Claude Code account to each project. Work repos run on the company seat, side projects stay personal — at the same time, in one window. Sign in to each account once; after that, opening a project just uses the right one.
An illustration of one lpm window running two Claude Code agents that stream in parallel. The left pane, project “client-app”, is pinned to a Work account and tightens a login rate limiter. The right pane, project “side-project”, is pinned to a Personal account and adds a dark mode toggle. A projects sidebar shows both as running, each tagged with its account, and the two panes advance at the same time — the accounts work side by side rather than one switching to the other.
Two projects, two subscriptions, no switching — each pane spends its own account’s usage.
Three Claude accounts, one CLI, endless juggling
Company seat, client seat, personal subscription — plenty of developers hold several Claude accounts. The tooling assumes you have one.
Claude Code signs into one account at a time
The CLI has no built-in profiles. Moving between a company seat and a personal subscription means /logout, a browser OAuth round-trip, and losing whatever the previous account had in flight. Do that four times a day and it stops being a login and starts being a tax.
Account switchers flip your whole machine
Tools like claude-swap swap the active credentials globally: every project changes account at once, and already-running sessions silently keep the old identity until you restart them. A switch made for one repo quietly re-routes every other repo too.
Work and personal usage blur together
Each Claude subscription has its own usage allowance. When one login serves every repo, a heavy afternoon on a side project eats the quota your work project needed — and there's no way to tell which project spent it.
Per-project Claude accounts, built into your terminal
Not a credential swapper — a project workspace that knows which identity each project uses.
Pin an account to a project
Add your accounts once in Settings, then assign one in the project's config. From that point every terminal you open in the project launches Claude Code on that account. Projects without a pin keep using your main login — nothing changes until you ask it to.
Accounts run in parallel, not in turns
This is a pin, not a switch. The work project runs the company seat while the side project runs your personal subscription — simultaneously, in adjacent panes. There is no global “active account” to flip and no restart ripple across running sessions.
Sign in once per account
The first terminal you open on a pinned project walks through Claude's normal browser sign-in for that account. That's the last time you see it. Every later terminal, on any project pinned to that account, is already signed in.
Your tokens stay where Claude put them
lpm never reads, copies, or exports credentials. Each account gets its own Claude Code home, and Claude Code itself keeps each login in the macOS Keychain — exactly as it does for a single account. No token files to back up, restore, or leak.
Your setup follows every account
Settings, memory, skills, and slash commands are shared across accounts automatically, so a pinned project feels identical to your main one — same tools, same shortcuts, different login. lpm's agent status badges keep working too.
Built-in AI features respect the pin
Commit messages, PR titles and descriptions, branch names, merge-conflict resolution, and composer text actions all run on the project's pinned account — not just the terminals. Whatever a project does with Claude, it does as the right identity.
Pinning vs. switching
Other setups can hold more than one Claude account — but each asks you to swap credentials, remember an env var, or leave the window. Pinning just points each project at its own account and leaves everything else alone.
| Capability | lpm | Account switchers | Manual CLAUDE_CONFIG_DIR | Separate macOS users |
|---|---|---|---|---|
| Accounts run at the same time | Yes | No | Yes | No |
| Pinned per project, not per machine | Yes | No | No | No |
| Never copies or moves credentials | Yes | No | Yes | Yes |
| Settings, memory & skills shared across accounts | Yes | Yes | No | No |
| Running sessions keep their account when you switch | Yes | No | Yes | Yes |
| No per-terminal exports or scripts to remember | Yes | Yes | No | Yes |
lpm
- YesAccounts run at the same time
- YesPinned per project, not per machine
- YesNever copies or moves credentials
- YesSettings, memory & skills shared across accounts
- YesRunning sessions keep their account when you switch
- YesNo per-terminal exports or scripts to remember
Account switchers
- NoAccounts run at the same time
- NoPinned per project, not per machine
- NoNever copies or moves credentials
- YesSettings, memory & skills shared across accounts
- NoRunning sessions keep their account when you switch
- YesNo per-terminal exports or scripts to remember
Manual CLAUDE_CONFIG_DIR
- YesAccounts run at the same time
- NoPinned per project, not per machine
- YesNever copies or moves credentials
- NoSettings, memory & skills shared across accounts
- YesRunning sessions keep their account when you switch
- NoNo per-terminal exports or scripts to remember
Separate macOS users
- NoAccounts run at the same time
- NoPinned per project, not per machine
- YesNever copies or moves credentials
- NoSettings, memory & skills shared across accounts
- YesRunning sessions keep their account when you switch
- YesNo per-terminal exports or scripts to remember
Zero to pinned in four steps
One-time setup, about two minutes. No config files required — the app writes them for you.
Add your accounts
Name them anything — Work, Client A. Your current login stays the default; you only add the extra ones.
SettingsAI & IntegrationsAdd account
Pin a project
Pick an account in the project's config form, or set claudeAccount in its YAML. Save.
ProjectConfigClaude account
Sign in once
The first terminal you open there runs Claude's normal browser sign-in for that account — the last time you'll see it.
Just work
Every terminal and AI feature in the project now uses its account. Other projects run theirs — in parallel.
Step 2 in the project’s config file — one line does it:
name: client-app
claudeAccount: workThree ways per-project Claude accounts pay off
Concrete setups where pinning beats switching.
Company seat and personal subscription on one Mac
Pin the client repo to your company seat and leave the side project on your personal login. Both agents run at the same time in adjacent panes, each spending its own subscription’s usage — and clicking between projects in the sidebar is the only “account switching” you ever do.
Duplicate a project ×5 to fan out agents — copies keep the account
lpm’s duplicate flow exists to spawn throwaway copies of a project and run agents on each in parallel. Duplicates inherit the parent’s pinned account automatically, so five copies of the work repo all run as the work identity — no per-copy setup, and no agent quietly burning your personal quota because a fresh copy fell back to the wrong login.
Keep client work billable to the client's seat
Freelancing across two clients, each providing their own Claude seat? Pin each client’s repo to that client’s account. Every agent session, every AI-generated commit message and PR description in that repo runs on the seat they pay for — clean separation you can stand behind, without ever re-authenticating mid-day.
What developers ask about running multiple Claude Code accounts
How is this different from claude-swap and other account switchers?
Switchers change the globally active account: back up the current credentials, restore another set, restart your sessions — and every project on the machine flips together. lpm doesn't switch anything. Each project is pinned to an account, all accounts stay signed in side by side, and two projects can run two different accounts at the same moment. There's also no credential handling: switchers copy token files or Keychain entries around; lpm just points each project at its own Claude Code home and lets Claude manage its own login there.I keep separate accounts because of usage limits — does each project get its own limit?
Each Claude subscription has its own usage allowance, and pinning means every session in a project draws from that project's account. A heavy afternoon on a side project can't eat the work seat's quota, and when a limit is hit you know exactly which account hit it.Do I have to log out and back in when I change projects?
No. You sign in to each account exactly once — the first time a project pinned to it opens a terminal. After that, moving between projects is just clicking in the sidebar; each project's terminals are already signed in as the right account, even when several projects with different accounts are running at once.Where are my credentials stored? Does lpm see my tokens?
Credentials live in the macOS Keychain, written and read by Claude Code itself — the same mechanism as a single-account setup, one entry per account. lpm never reads, stores, copies, or exports tokens, and nothing sensitive lands in lpm's own files. Removing an account from lpm doesn't touch the login; it just stops projects from using it.Do my settings, memory, and skills work on every account?
Yes. Your Claude Code settings, memory file, skills, custom agents, and slash commands are shared across all accounts automatically, so a pinned project behaves exactly like your main setup — same commands, same tools, different identity. lpm's agent status badges (working / needs approval / done) keep working on pinned projects too.What happens to the account I already use?
Nothing. Your existing login stays the default: any project without a pin keeps using it, and you don't re-authenticate anything. You only add the extra accounts — a work seat, a client seat — and pin them where they belong.I use an API key in some projects — does pinning interfere?
No; the pin decides which stored subscription login Claude Code uses, and a project that exports ANTHROPIC_API_KEY keeps billing to that key exactly as before.Does this work for Codex or other coding agents?
Pinning is Claude Code–specific today. Codex runs in lpm terminals right alongside your pinned projects, but on its own single login — there's no per-project account for it yet.Any limitations I should know about?
Account pinning applies to projects that run on your Mac — SSH projects use whatever Claude login exists on the remote host. It also relies on Claude Code's per-home credential isolation, which shipped in early 2026, so keep Claude Code reasonably up to date. Terminals that are already open keep the account they launched with; a new pin applies to terminals you open afterwards. And one gotcha — if you set CLAUDE_CONFIG_DIR by hand in your shell profile (~/.zprofile, ~/.zshrc), remove it: a login shell re-sources it and overrides the per-project account.
Keep reading
Best terminal for Claude Code & Codex
Run Claude Code and Codex in parallel on the same codebase, with your dev stack alongside.
Connect AI agents to your projects
Let agents start, stop, and restart services, read dev-server logs, and fan out into parallel copies.
Claude Code & Codex token usage
Track usage across projects, providers, models, and recent sessions without sending the dashboard to the cloud.
Claude Code & Codex statuslines
Pick a preset, reorder the fields, and preview live — so you can tell each session apart at a glance.
Stop switching accounts.
Start pinning them.
Download a native macOS app, add your Claude accounts in Settings, and pick one per project. Works on Intel and Apple Silicon Macs running macOS 12 or later.