Use case

A new engineer's agent knows nothing about your project. Set it up once on day one.

Context Mode keeps your skills, rules and project facts on the engineer's account, not on one laptop. They set it up once on day one, and each later session in either agent gets the skill that matches, the rules and the facts that fit.

Day one

The lead hands over three things: the skills repo, the rules text, a short facts note.

Built into each agent

  • Skills: in each repo, or a folder per agent
  • Rules: CLAUDE.md for one agent, AGENTS.md for the other
  • Facts: told again, or in a file the client loads

Through Context Mode

  • One skills catalog for both agents
  • One rules text for both agents
  • Facts kept by Memory

The engineer sets this up once, on their own account. Any laptop they use then has it.

Paste the team's skills repo once.

Console → Skills
https://github.com/owner/repo
Preview import → Add all
Your skillsdiagnosing-bugsto-tickets

The skill that matches the message loads. One per turn at most, named in the reply.

Paste the rules once, in Settings.

// Settings → Instructions
Keep answers short. No wall of text.

Every request from both agents carries it, on every machine. Costs almost nothing after the first request.

The engineer pastes the lead's note: “Our production deploy target is Render, Oregon region.”

FactValueValid fromUntil
production deployed_toRender, Oregon regionday onenow
A new session, later:
“Where do we deploy production?”
→ Render, Oregon region.

A new conversation gets the current facts that fit the question. A fact that changes later closes the old row and keeps it as history.

The problem

Day one, empty agent. Someone explains it all again.

It does not know the facts

A coding agent starts each session with what its client loads, and nothing more. The deploy target, the on-call engineer and the CI are not in it.

Files per agent

Built-in skills and rules are files: CLAUDE.md for one agent, AGENTS.md for the other, in each repo or folder. Two agents mean two sets to keep the same.

Facts stay in one chat

The lead explains the deploy target in chat. The next session needs it told again, or written into a file the client loads.

How it works

Set it up once. Every laptop they use gets it.

  1. 01The lead hands over three things

    The skills repo URL, the rules text and a short note of project facts. On Team, each member's account is their own, so each new engineer does this setup once.

  2. 02Import the skills, paste the rules

    Paste the repo URL in Skills, preview, then add all. Paste the rules in Settings, 4,096 characters at most. Every request carries them.

  3. 03Paste the facts in the first session

    Memory keeps at most 5 facts from each turn, and the facts learned in later weeks. A new conversation gets the current ones that fit the turn.

The new engineer's agent sends a request to Context Mode. Context Mode adds the skill that matches and your instructions. In a new conversation it also adds the current project facts that fit, from Memory. Then the request goes to your model account. New engineer their agent a new laptop, day one Context Mode the skill that matches your instructions current project facts The model Anthropic or OpenAI
After day one, each request carries the rules and the skill that matches. A new conversation also gets the current facts that fit.
Proof

Facts kept between sessions. Through Context Mode.

One catalogof skills for both agents, imported once from a GitHub repo
One textof rules in Settings, carried by every request from both agents
8 of 8facts right in new sessions; the full test is on Shared context

The facts figure is a small live eval in Claude Code. Method and sources →

Day one, side by side

What the new agent has. Before it asks.

Context ModeBuilt into each agent
Team skillsOne catalog for both agents, on any machineFiles per agent, in each repo, a plugin or a folder
House rulesOne text for both agents, every machineCLAUDE.md for one agent, AGENTS.md for the other
Project factsKept from sessions; a changed fact closes the old oneTold again, or written into a file the client loads
Two agentsClaude Code and Codex share one storeSeparate local memories

On Team, each member's memory stays their own, and skills and instructions are set per account. So each new engineer does the setup once. A skill kept in the repository is still reviewed in git like code. See plans →

Products used

What this uses.

Memory

Facts from your sessions. A new conversation gets the current ones that fit.

Skills

Import from GitHub once. The skill that matches loads, named in the reply.

Instructions

Rules you write once in Settings, carried by every request.

Memory docs

Where facts apply, who wrote them, and how it was tested.

Related: Same rules for every engineer · Stop explaining your project · Share skills

One setup on day one. Not one per session.

npx @context-mode/cli connects your agents. 1,000 requests free, no card.

Get started free

Your coding agent costs less and remembers your project.

Start free: 1,000 requests, every feature, no card. After you sign in, the console gives you one command to connect Claude Code or Codex.

Read the docs