Onboard your team to agentCircles

For the person who looks after your team’s agents. It takes you from an invite code to your agent’s first session with memory, in one terminal, in about 20 minutes. You can do it alone or on the kickoff call with us.

npx @circles/cli onboard --invite <your code>

Before you start

Your invite code. It came by email after we approved your request. It works once and lasts 7 days.
Node 22, git and Claude Code on your machine.
A GitHub or Google account that holds the email address we invited, verified. The wizard asks which one you want to sign in with.
A terminal opened in the repo your agent works in.

Want to look first? Add --check. It shows how your files would be sorted and sends nothing.

npx @circles/cli onboard --check

What you’re setting up

Your team’s memory sits in circles. On the outside, each agent has its own: notes from the task it’s on, and what it has learned so far. In the middle are the lessons your team has approved, and at the centre, your decisions. Between the two is review, where anything an agent proposes waits for a person.

When an agent starts a session it gets its slice: its own memory, the team’s lessons and the decisions that matter for the task. It never sees another agent’s private memory, and it never reads the review queue.

The four steps

The wizard checks Node, git and Claude Code. Then it shows a one-time code and opens your browser. Approve it with GitHub or Google and the wizard carries on by itself.

You name your team and your first agent. You become the team’s admin, and you sponsor that agent: it can never see more than you can. Your key and the agent’s go into the macOS Keychain. On other systems they go into ~/.circles/credentials.json, readable only by you. No key is written into your repo.

2. Scan and sort

The wizard reads the memory files in your repo: CLAUDE.md, AGENTS.md, agent definitions, memory folders and ADR folders. This happens on your machine. It sorts them into decisions, team lessons and each agent’s own memory, and shows you the list.

Two things are flagged here. Secrets are counted, never shown, and will be blanked before anything is stored. Text that reads like instructions to an agent will be held until you release it.

Type the numbers of any files you don’t want imported. They are added to .circles/bridge.yaml so later syncs skip them too.

3. Import and review

One approval sends the files you left ticked. From here every file follows the same path a new idea from an agent would follow.

An agent’s own memory folder goes straight into that agent’s private memory.
Everything shared (CLAUDE.md, AGENTS.md, retros, ADRs) becomes a draft in review, proposed by your agent.

Then you review, in this order:

Conflicts. Two files that contradict each other, or a file that contradicts memory already in force. For each one you keep one side, split the scope, keep both, or leave it for later.
Merged lessons. Files that said the same thing became one draft. It lists every file it came from.
The rest. Approve them all in one go.

Only what you approved reaches your agent. Anything left in conflict waits, and your agent acts on neither side.

4. Connect your agent

The wizard writes the Claude Code hooks into .claude/settings.local.json, which git ignores, and adds the agentCircles server to Claude Code. Start claude in another terminal. The wizard waits for that first session and then prints exactly what your agent received: its own memory, the team lessons, the decisions in force.

Ask your agent what it remembers about the repo. From that session on, your agent starts with memory.

Where each file lands

File	Becomes	Needs your review
An agent’s memory folder	That agent’s private memory	No
Agent definition files	The agent’s profile	No
`CLAUDE.md`, `AGENTS.md`, retros	Team lesson drafts	Yes
ADR folders	Decision drafts	Yes

What leaves your machine

Nothing, until you approve the import in step 3.
After that, only the files you left ticked. Secrets in them are replaced with [REDACTED] before they are stored.
From your sign-in we keep your account id, your login and your verified email. Nothing else.

If you change your mind

circles import undo

It works for 7 days. It withdraws the drafts and archives what the import created. It never touches anything that existed before the import, and nothing is deleted: archived memory stays on record.

Afterwards

Command	What it does
`circles status`	Your quick-start checklist
`circles review list`	Drafts waiting for you, from imports, syncs and agents alike
`circles conflicts list`	Contradictions waiting for a decision
`circles invite name@company.com`	Invite a teammate. The code works only for an account that holds that email.
`circles connect <agent>`	Connect another agent, or the same agent on another machine
`circles sync --watch`	Keep your files in sync. Shared files still go through review.
`circles quarantine list`	Text held back because it reads like instructions to an agent
`circles login`	A fresh 30-day key by the same sign-in you joined with
`circles doctor`	What stands between this machine and a working session

Cursor and Codex connect too. See the connect guides for what each one gets.

If something goes wrong

Start with circles doctor. It lists what’s missing on this machine.
The wizard stopped halfway. Run the same command again. It picks up where it stopped.
Your agent’s tools answer 401 after onboarding. Run circles connect <agent> --static-mcp-header. The key then sits in ~/.claude.json, outside your repo, instead of being read from the Keychain.
The invite code is refused. It has been used, it is older than 7 days, or the account you signed in with doesn’t hold the invited email. Write to us and we’ll send a new one.
Still stuck. Write to support@agentcircles.ai with the output of circles doctor. A founder answers.

What we’ll ask of you during early access

A 30-minute call each week for three weeks, and your honest read on whether your agents work better with memory than without it. Your memory stays yours: circles export writes all of it out whenever you like.