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.

[Get started free](https://console.context-mode.com/login) [Read the docs](https://context-mode.com/docs/memory)

Day one

New laptop Team skills House rules First session

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 skills *diagnosing-bugs* *to-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.”

| Fact | Value | Valid from | Until |
| --- | --- | --- | --- |
| `production deployed_to` | Render, Oregon region | day one | now |

```
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. 01 **The 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. 02 **Import 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. 03 **Paste 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.

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 catalog** of skills for both agents, imported once from a GitHub repo **One text** of rules in Settings, carried by every request from both agents **8 of 8** facts right in new sessions; the full test is on [Shared context](https://context-mode.com/solutions/shared-context)

The facts figure is a small live eval in Claude Code. [Method and sources →](https://context-mode.com/docs/memory#live-eval)

Day one, side by side

## What the new agent has. *Before it asks.*

|  | Context Mode | Built into each agent |
| --- | --- | --- |
| Team skills | One catalog for both agents, on any machine | Files per agent, in each repo, a plugin or a folder |
| House rules | One text for both agents, every machine | CLAUDE.md for one agent, AGENTS.md for the other |
| Project facts | Kept from sessions; a changed fact closes the old one | Told again, or written into a file the client loads |
| Two agents | Claude Code and Codex share one store | Separate 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 →](https://context-mode.com/pricing)

Products used

## What this *uses.*

**[Memory](https://context-mode.com/memory)**

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

**[Skills](https://context-mode.com/skills)**

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

**[Instructions](https://context-mode.com/instructions)**

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

**[Memory docs](https://context-mode.com/docs/memory)**

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

Related: [Same rules for every engineer](https://context-mode.com/solutions/team-standards) · [Stop explaining your project](https://context-mode.com/solutions/shared-context) · [Share skills](https://context-mode.com/use-cases/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 →](https://console.context-mode.com/login) [Read the docs →](https://context-mode.com/docs/skills)