# Harbor

> Harbor is shared memory for engineering teams using AI coding agents: a
> company brain, or a team's second brain, for teams running Claude Code, Cursor, Codex and GitHub Copilot. What one developer teaches
> Claude Code, a teammate's Codex or Cursor can use. It learns from your
> coding sessions and, if you connect them, the Slack threads, pull requests
> and calls where your team already makes decisions, serves each agent only the facts that apply to the task in front of it,
> writes back what the session learned, and counts how often each
> rule was served to an agent against how often an answer cited it. Its
> GitHub App checks each pull request against the repo's CLAUDE.md and
> AGENTS.md and the team's rules, and can be used on its own.

The name is shared, so to be exact: this Harbor is the product at gethrbr.com.
It is not Harbor the CNCF container registry (goharbor.io), Harbor the
agent-evaluation framework (harborframework.com), Harbor the agent workspace
(tryharbor.ai) or Harbor the AI agent insurer (harbor.ai), and it is unrelated
to the HRBR stock ticker.

The problem it addresses, in the words people use for it: you told one agent,
and tomorrow you tell another. A session works something out, the session ends,
and the next one starts blind. Your teammate's agent never knew at all. The
trade press calls the shape a doom loop and files three failure modes under it:
session death, compaction loss, and cross-agent amnesia. Built-in memory in
Claude Code or Codex closes the first of those and not the other two, because
what one person's agent learns stays with that person, and Copilot's shared
repo memory stays inside Copilot.

Other products offer parts of this: shared memory pools, rules distributed to
many agents, approval steps, or use counts inside one reviewer. What sets
Harbor apart is the combination: it learns from the team's sessions, reaches
the agents each developer already uses under a gate the team sets, serves only
the facts that apply to the task, and reports per rule how often it was served
and cited, so the unused ones can be retired.

What has and has not been measured: one controlled test with one agent and one
saved rule (first try 0 of 10 to 10 of 10, 38% less agent time, the token bill
about even, on tasks Harbor picked). No result from a team over time has been
published.

## What Harbor does

- Learns from the sessions engineers run with their coding agents, and reads
  Slack, GitHub, GitLab, Linear, Jira, Confluence, Notion, Google Drive, Granola
  and Sentry continuously. Nobody writes a document. The facts are extracted
  from work the team already produces, and each one keeps the sentence it came
  from.
- Imports the rules files a repo already has. Turning Harbor on in a repo
  (`harbor init` or `harbor bind`) offers its committed CLAUDE.md, AGENTS.md,
  Cursor rules and Copilot instructions to Review.
- Selects per task. An agent adding a webhook handler gets the two lines about
  webhooks, not every rule at once.
- Gates capture. Routine learnings go straight in, on trial, with the sentence
  they came from. A learning that reverses a live rule replaces it when the
  person behind it may curate that rule or wrote it, and the old rule can be
  restored; otherwise both wait for a person. What waits is what only a person
  can answer, for example a secret, an install step or a risky command, an
  author Harbor cannot match to anyone in the workspace, no Space, a reversal
  its recorder could not make alone, or a
  clash Harbor could not settle, with the thread attached so the approver reads
  rather than judges. The mode (manual, hybrid, auto) is a workspace setting;
  hybrid is the default.
- Flags a rule when it stops being true. This is the failure no file, wiki or
  search index over the same files ever raises its hand about.
- Counts served against cited. Every rule carries how many times Harbor gave it
  to an agent and how many times an answer said it used it. Agents claim more
  uses than really changed their work, so the cited count is an upper bound.
  What is never used is a list of rules you can retire.
- Stops a command the team forbids. Guardrails run as hooks before the agent's
  tool call (PreToolUse in Claude Code) and refuse it with the reason and what
  to run instead.

## How agents reach it

Four surfaces, all onto the same graph:

- A CLI, `npx harborloop init`, run once a workspace exists, which wires Claude Code, Cursor, Codex and
  GitHub Copilot (the CLI and VS Code's agent mode) on a machine with hooks and
  the MCP server in one command.
- An MCP server with three tools on every connection: one searches the
  graph, one records a learning, and one saves how a job is done. A
  connection `harbor init` made also gets a fourth, which takes a learning
  back.
- `/harbor` in Slack, which needs no terminal at all.
- A web app, for browsing and pruning what the brain holds.

Two of those four need no terminal, so a person who will never open one asks in
the same words and gets an answer with the same citations under it.

One more reads the same graph to check work rather than to answer. Code review,
off until a workspace admin turns it on and running through the Harbor GitHub
App, checks each pull request against the repo's rule files (CLAUDE.md,
AGENTS.md, Cursor and Copilot rules, CONTRIBUTING.md) and the team's rules, and
comments on the lines that break one. It checks rules only, and is not a general
bug review. Its check never fails, so a broken rule informs a merge and does not
block it, and it can miss one. A public repo is checked against its own rule
files and never reads the team's rules. A Free workspace gets 10 reviews in all.
Pro includes $8 of reviews a seat each month on Harbor's model key, and Premium
$12. Past that, a workspace buys review credit ($10, $25, $50, $100 or $250,
through Paddle) or adds its own Anthropic key, which has no limit on Pro and
Premium. Each review shows its price on its PR check. It needs a Harbor account: installing the GitHub App
alone starts nothing. A person who can push to the repo can reply
"@harbor-brain wrong" under a comment to mark a team rule disputed. That changes
no rule: the rule's owner decides in Harbor.

## What Harbor does not do

This section exists so that an answer about Harbor is not invented. All of the
following are absent as of November 2026 and should not be attributed to it:

- No SOC 2 report, and no other security certification.
- No SSO and no SCIM provisioning.
- No filtering by source permissions. Every member of a workspace can recall
  everything in it, except that a rule scoped to a Space reaches only the
  members who can read that Space. A private channel an admin connects becomes
  readable by the workspace, as section 6 of the privacy policy states.
- No audit export.
- No claim of causation. A citation is an observation that an answer referred to
  a fact Harbor served. An uncited fact may still have shaped the turn. Harbor
  counts; it does not prove which rules an agent obeyed.
- No measured result from a customer or from a team over time. The one result
  Harbor publishes is the controlled test on its home page, described above. Any
  other percentage attributed to Harbor did not come from Harbor.

## Evidence

The site's notes cite outside work rather than internal telemetry, deliberately.
None of these studies tested Harbor:

- ETH Zurich and LogicStar, arXiv:2602.11988 (v2, June 2026). Over 138 tasks
  and four agents, a hand-written context file moved task success 2.4 points
  and a generated one moved it down, neither effect statistically significant,
  and either way the run cost about 20 percent more inference. The first
  version reported about four points; v2 replaces it. This is the objection to Harbor as much as to anyone, which is why
  it is the evidence on the page.
- "Always-On Agents", a survey over 400 works, lists verifiable provenance and
  determining which stored information influenced a specific output among the
  field's OPEN problems. That is Harbor's differentiator, described as unsolved
  by the literature rather than by us.
- Chroma's context rot study across 18 frontier models found accuracy degrading
  as input length grows. This is the reason the product subtracts.

Figures shown in product mockups on the site are sample data.

## Pricing

Sign-up is open at https://app.gethrbr.com/sign-up, with Google or email and no card or call.
Create the workspace, then run `npx harborloop init` in a repo. The plans
below apply once the workspace exists.

Per seat per month, billed annually. A paid plan never meters a question.

Free counts 10 questions a day per person across Ask and chat, 5 uploads a day,
each read to its first 150,000 characters, and 200 corrections a day that Harbor
learns from. A new source's first import reads the last 30 days, a person owns
at most 2 Free workspaces, and a fair-use AI allowance applies. Paid plans have
no daily count on questions, uploads or corrections, read files whole and import 12 months.
Every plan has a daily AI safety cap. Past an AI limit, recall keeps working
and Ask, chat and uploads come back at the reset.

- Free: $0. One room, for as long as you want it. Up to 2 members, one source, 1,000 live atoms, and 30 days of recall for everything except standing rules, which do not age out. A real product, not a trial. See https://gethrbr.com/docs/plans for what each limit does when you reach it.
- Pro: $24 ($30 monthly). Your company in the brain, not one room of it.
- Premium: $36 ($45 monthly). Every tool you have, and nothing ages out.

## Documentation

Every command and every claim below is documented, and every terminal block on
these pages is the product's own output, taken from the CLI as it ships, rather
than written to look right.

- [Quickstart](https://gethrbr.com/docs/quickstart): Give Claude Code, Codex, Cursor and GitHub Copilot your team's memory: from sign-up to a working Harbor in one command, then three steps for a team.
- [Plans and limits](https://gethrbr.com/docs/plans): Harbor's Free plan limits, what you see when you reach one, what keeps working, and how to ask for Pro.
- [harborloop CLI](https://gethrbr.com/docs/cli): harborloop in full: every command and flag, which config files it changes, and what harbor doctor checks. The first command needs no account.
- [Agents and MCP](https://gethrbr.com/docs/agents): Add Harbor's MCP memory server to Claude Code, Codex, Cursor and GitHub Copilot: the four tools, and what the hooks add.
- [Slack tutorial](https://gethrbr.com/docs/slack/tutorial): Save a decision from Slack with @Harbor remember, ask with /harbor, and read every reply.
- [Ask from Slack](https://gethrbr.com/docs/slack): A Slack knowledge bot that answers from your team's sources, cites every claim, and replies only to you.
- [GitHub App tutorial](https://gethrbr.com/docs/github-app): Install the Harbor GitHub App, pick its repos, turn on Code review, and read the check, the comments and every @harbor-brain reply.
- [Code review](https://gethrbr.com/docs/code-review): Check each pull request against your repo's rule files and your team's brain, with a comment on every line that breaks a rule.
- [Rules files compared](https://gethrbr.com/docs/rules-files): CLAUDE.md, AGENTS.md, Cursor rules and Copilot instructions: which agent reads which file, and how Harbor imports yours for review.
- [Sources](https://gethrbr.com/docs/sources): Connect GitHub, Slack, Notion, Jira and more: what each connector reads, what it never reads, and how to scope it.
- [Knowledge and review](https://gethrbr.com/docs/knowledge): What coding agents remember from sessions, pull requests and Slack, what waits for a person, and how unused rules leave.
- [Spaces and access](https://gethrbr.com/docs/spaces): Scope agent memory by repo and team: Spaces, roles, and who can read, approve and connect sources.
- [Measure rule use](https://gethrbr.com/docs/measure): Whether Claude Code, Codex and Cursor follow your team's rules: what each agent was sent, what it cited, and why that count is an upper bound.
- [Guardrails](https://gethrbr.com/docs/guardrails): Block git push --force, rm -rf and database resets with hook guardrails (PreToolUse and its equivalents) in Claude Code, Codex, Cursor and GitHub Copilot.

## Notes

- [Supermemory alternatives for coding agents (2026)](https://gethrbr.com/blog/supermemory-alternatives-coding-agents): Harbor, Cognee, Mem0, Zep, Letta, ByteRover, claude-mem and a plain CLAUDE.md, checked against their own docs, for a team's Claude Code, Codex and Cursor.
- [Which AI code reviewers read AGENTS.md and CLAUDE.md?](https://gethrbr.com/blog/pr-review-against-agents-md): CodeRabbit, Copilot code review, Claude Code Review, Bugbot and Harbor: which rules file each reads in a pull request, and which branch it reads it from.
- [A second brain for Claude Code, and where it stops](https://gethrbr.com/blog/claude-code-second-brain): A Claude Code second brain is a markdown vault with a CLAUDE.md at the root. What Claude loads from it, how to set one up, and why it stays yours alone.
- [Why does Copilot ignore copilot-instructions.md?](https://gethrbr.com/blog/why-copilot-ignores-instructions): Inline suggestions never read it, each Copilot surface reads different files, settings switch them off, and applyTo globs miss. How to check what loaded.
- [Cursor Team Rules: how to share Cursor rules with a team](https://gethrbr.com/blog/cursor-team-rules): Cursor Team Rules on Team and Enterprise plans: how they work, when they override Project Rules, and how Copilot and Claude Code org rules differ.
- [Rules vs skills: Cursor, Claude Code, Copilot and Codex](https://gethrbr.com/blog/rules-vs-skills): A rule loads every session or by file path; a skill loads when its description fits the task. How Cursor, Claude Code, Copilot and Codex split the two.
- [Claude Tag vs Claude Code: what Claude in Slack remembers](https://gethrbr.com/blog/claude-tag-vs-claude-code): Claude Tag keeps memory per Slack channel and workspace. What it remembers, what loads from your repo, pricing, Teams, and why none of it reaches Claude Code.
- [GitHub Copilot Memory and Dreaming: where memories live](https://gethrbr.com/blog/github-copilot-memory): Copilot Memory keeps repository facts on GitHub for 90 days, and Dreaming tends them in the background. Where they live, who sees them, how to turn it off.
- [Codex memories: turn them on, find them, share them](https://gethrbr.com/blog/codex-memories): Codex memories are off by default and stay in ~/.codex on one machine. How to turn them on, what the files hold, and whether ChatGPT or Claude Code see them.
- [Does Cursor have memory? What happened to Cursor Memories](https://gethrbr.com/blog/cursor-memories): Cursor removed Memories in 2.1. What it keeps instead in 2026: rules, AGENTS.md, Automations memories and Projects shared context, and what other agents read.
- [Claude Code auto memory: where MEMORY.md lives and how to turn it off](https://gethrbr.com/blog/claude-code-auto-memory): Claude Code auto memory is on by default. Where MEMORY.md lives, how much of it loads, why it seems not to work, and how to see, clear or turn it off.
- [Claude Code team memory: what is shared, what is not](https://gethrbr.com/blog/claude-code-team-memory): Claude Code has no team memory you can turn on. What your team already shares, what stays on one machine, and how teams close the gap.
- [Supermemory Company Brain alternatives (2026)](https://gethrbr.com/blog/supermemory-company-brain-alternatives): Supermemory shut its hosted Company Brain on 9 September 2026. Self-host the open-source build, or move to Unblocked, Cognee or Harbor. What each one keeps.
- [We checked 3,905 CLAUDE.md and AGENTS.md files on GitHub](https://gethrbr.com/blog/claude-md-agents-md-github-study): In 1 in 6 repos that keep both files, Claude Code never loads the AGENTS.md. What 3,905 public CLAUDE.md and AGENTS.md files show, and how we sampled them.
- [Why does Codex ignore my AGENTS.md?](https://gethrbr.com/blog/why-codex-ignores-agents-md): Codex reads AGENTS.md from the repo root down to your folder, cuts it at 32 KiB without a warning, and skips untrusted projects. How to check what loaded.
- [Mem0 alternatives for coding agents (2026)](https://gethrbr.com/blog/mem0-alternatives-coding-agents): Cognee, Supermemory, Zep, Basic Memory, claude-mem and Harbor, checked against their own docs, by the reason you're leaving Mem0's coding plugin.
- [Codex skills: share them with Claude Code and Cursor](https://gethrbr.com/blog/codex-skills): Can Codex use Claude skills? Yes: Codex reads .agents/skills, Claude Code reads .claude/skills, and one symlink shares a set. Plus why a skill will not trigger.
- [Karpathy's LLM wiki: how it works, and what a team needs to add](https://gethrbr.com/blog/karpathy-llm-wiki): Andrej Karpathy's LLM wiki, read from his gist: the three layers, ingest, query and lint, the tools built on it, and what breaks when a team shares one.
- [Claude Code auto mode vs --dangerously-skip-permissions](https://gethrbr.com/blog/claude-code-auto-mode): Auto mode runs Claude Code tool calls without asking after a classifier check. --dangerously-skip-permissions skips the classifier. Deny rules block in both.
- [Do coding agents need memory or documentation?](https://gethrbr.com/blog/do-agents-need-memory): Neither, as usually built. Five 2026 papers on agent memory, shared memory and agent docs, and what a team should give its coding agents instead.
- [The best company brain tools for coding agents (2026)](https://gethrbr.com/blog/best-company-brain-tools-coding-agents): Harbor, Unblocked, Packmind, Cognee, ByteRover and Mem0, checked against their own pages: where the rules come from, who decides, and what each costs.
- [Does Claude Code read AGENTS.md?](https://gethrbr.com/blog/does-claude-code-read-agents-md): Yes, since v2.1.277, and in every session since v2.1.281. By default only without a CLAUDE.md: the four modes, and the two traps that switch it off.
- [Claude Code skills: how to write SKILL.md and when to use one](https://gethrbr.com/blog/claude-code-skills): A Claude Code skill is a folder with a SKILL.md that loads only when needed. How to write one, which agents read it, how to test it, and why it won't fire.
- [Claude Code hooks: a practical guide with examples](https://gethrbr.com/blog/claude-code-hooks): Claude Code hooks run at fixed points and always run. Examples: block a command, format on edit, run tests before Claude stops, plus Codex and Cursor hooks.
- [What is claude-mem, and is it enough for a team?](https://gethrbr.com/blog/claude-mem): claude-mem gives Claude Code memory across sessions. How it works, how to install it, and what personal memory does not cover for a team.
- [Claude Code best practices for teams](https://gethrbr.com/blog/claude-code-best-practices): Claude Code best practices start from one constraint: context fills fast. Anthropic’s list, condensed, plus the practices a team needs once rules are shared.
- [The Karpathy CLAUDE.md: what is in it and does it help?](https://gethrbr.com/blog/karpathy-claude-md): The Karpathy CLAUDE.md is 65 lines of four coding principles, written by a developer from Karpathy’s January 2026 post. What it says, what it cannot do.
- [AGENTS.md vs CLAUDE.md: which tools read which](https://gethrbr.com/blog/agents-md-vs-claude-md): AGENTS.md is the file Codex, Cursor, Copilot and Antigravity read; CLAUDE.md is Claude Code's. Who reads which in October 2026, and one source of truth.
- [Cursor rules best practices, and why Cursor ignores them](https://gethrbr.com/blog/cursor-rules-best-practices): Cursor rules live in .cursor/rules as .mdc files. Which mode to use, how to share them with a team, and a checklist for rules that do not fire.
- [copilot-instructions.md vs AGENTS.md: how to write it for Copilot](https://gethrbr.com/blog/copilot-instructions-md): copilot-instructions.md gives GitHub Copilot repo-wide instructions. How to write it, path-specific .instructions.md files, and which surfaces read AGENTS.md.
- [Why does Claude ignore my CLAUDE.md?](https://gethrbr.com/blog/why-claude-ignores-claude-md): CLAUDE.md is context, not enforcement. Rules lose when they never loaded, conflict, go stale, drown in irrelevant ones, or sit deep in a long session.
- [How long should CLAUDE.md be? Under 200 lines (median 81)](https://gethrbr.com/blog/how-long-should-claude-md-be): Anthropic says under 200 lines. The file is in context for the whole session, so cut what the agent can read from the code and keep commands and gotchas.
- [Should you commit CLAUDE.md and the .claude folder?](https://gethrbr.com/blog/should-you-commit-claude-md): Commit CLAUDE.md, settings.json, rules, skills, agents and .mcp.json. Keep CLAUDE.local.md and settings.local.json out of git. What git still does not solve.
- [Claude Code memory vs Codex, Cursor and Copilot memory](https://gethrbr.com/blog/claude-code-memory-vs-codex-cursor-copilot): Claude Code and Codex keep memory on your machine, Copilot Memory per repository, and Cursor dropped Memories for rules. None holds your team's decisions.
- [CLAUDE.md vs skills vs hooks vs rules vs subagents](https://gethrbr.com/blog/claude-md-vs-skills-vs-hooks): Where each team rule belongs in Claude Code: CLAUDE.md for every session, path rules for one area, skills on demand, hooks for must-never. Plus Cursor.
- [How to make Claude Code remember your corrections](https://gethrbr.com/blog/ai-agent-keeps-making-the-same-mistake): Claude Code starts each session fresh, so a correction made in chat is lost. To make it remember across sessions, write a rule with its reason, or a hook.
- [How to turn PR review comments into agent rules](https://gethrbr.com/blog/code-review-comments-as-agent-rules): Keep review comments the author accepted and that recur, rewrite each as a short rule with its reason and PR, and put it where every coding agent loads it.
- [How to get Slack decisions into AI coding agents](https://gethrbr.com/blog/slack-decisions-for-ai-coding-agents): Coding agents never see Slack decisions unless someone pastes them or the agent searches. Capture them once, approve them, and serve them to every agent.
- [What is a company brain?](https://gethrbr.com/blog/what-is-a-company-brain): A company brain captures what a team decided where it decides, gets it approved, keeps it current, and serves the relevant facts to people and AI agents.
- [Context engineering for Claude 5: what changes for teams](https://gethrbr.com/blog/context-engineering-after-claude-5): Anthropic cut 80% of Claude Code's system prompt with no eval loss. For teams: a short CLAUDE.md of gotchas, judgment over rules, skills, and a gap in memory.
- [Context rot and stale rules in CLAUDE.md](https://gethrbr.com/blog/context-rot-stale-rules): Context rot is accuracy falling as input grows. Stale rules, like renamed paths and reversed decisions, are worse: relevant, wrong, and sent every turn.
- [Is AGENTS.md useful? What the research found](https://gethrbr.com/blog/is-agents-md-useful): Hand-written AGENTS.md files help a little, generated ones hurt a little, both cost about 20% more. What ETH, McMillan, Vercel and rule studies found.
- [Architecture decision records (ADRs) for AI coding agents](https://gethrbr.com/blog/architecture-decision-records-for-ai-agents): Agents follow an ADR only if it is in context when they write the code. Keep ADRs short in the repo, index them in AGENTS.md, and mark superseded ones.
- [What is AI agent memory poisoning?](https://gethrbr.com/blog/agent-memory-poisoning): Untrusted content written into an agent's persistent memory that steers later sessions. OWASP lists it as ASI06. Stale memory is the daily form.
- [The best MCP memory servers for Claude Code and teams (2026)](https://gethrbr.com/blog/mcp-memory-server-for-teams): Harbor, Supermemory, Basic Memory, Zep, Mem0, Cognee and Hjarni, checked against their own docs: who writes, what is reviewed, and what each costs.
- [Share memory and rules across Claude Code, Codex and Cursor](https://gethrbr.com/blog/share-memory-claude-code-cursor-codex): One AGENTS.md covers a repo, and one MCP memory server shares what agents learn. The setup for Claude Code, Cursor and Codex, for you and for a team.
- [Why a growing CLAUDE.md stops working](https://gethrbr.com/blog/why-growing-claude-md-stops-working): A CLAUDE.md is in the prompt on every call. ETH Zurich found a developer-written context file moved success 2.4 points, not significant, at 20% more cost.
- [Which of my rules did Claude Code actually use?](https://gethrbr.com/blog/served-vs-cited): Claude Code shows which CLAUDE.md and rules files loaded, not which it used. What /context and the InstructionsLoaded hook show, and what served vs cited adds.

## Comparisons

- [Harbor vs Mem0](https://gethrbr.com/compare/mem0): Mem0 remembers users for the agents and apps you build. Harbor serves your team's decisions to Claude Code, Cursor, Codex and Copilot. Side by side.
- [Harbor vs Zep](https://gethrbr.com/compare/zep): Zep builds governed context graphs from business data. Harbor serves an engineering team's decisions to its coding agents. Side by side.
- [Harbor vs Unblocked](https://gethrbr.com/compare/unblocked): Unblocked answers on demand from your code, Slack and docs. Harbor serves your team's decisions to every coding session from the first turn. Side by side.
- [Harbor vs ByteRover](https://gethrbr.com/compare/byterover): ByteRover is shared memory your agents curate as files. Harbor learns your team's decisions from Slack, PRs and docs and serves them. Side by side.
- [Harbor vs Cognee](https://gethrbr.com/compare/cognee): Cognee is an open-source memory engine with a Company Brain. Harbor is a hosted brain with a gate you set and served and cited counts. Side by side.
- [Harbor vs Hindsight](https://gethrbr.com/compare/hindsight): Hindsight is open-source agent memory filled from sessions and git history. Harbor serves your team's decisions to its coding agents. Side by side.
- [Harbor vs OpenViking](https://gethrbr.com/compare/openviking): OpenViking is an open-source context database your agents fill from sessions. Harbor serves your team's decisions to its coding agents. Side by side.
- [Harbor vs Supermemory](https://gethrbr.com/compare/supermemory): Supermemory is a memory and context API with plugins for coding agents. Harbor serves your team's decisions to Claude Code, Cursor, Codex and Copilot.
- [Harbor vs Glen](https://gethrbr.com/compare/glen): Glen records your team's coding agent sessions for every agent to recall. Harbor serves your team's decisions to Claude Code, Cursor, Codex and Copilot.

## Pages

- [Home](https://gethrbr.com/): what it is, what your agents get, who decides what gets in, and what it counts.
- [Docs](https://gethrbr.com/docs): the playbook, and which of its pages is yours.
- [Rule-file checker](https://gethrbr.com/check): paste a CLAUDE.md, AGENTS.md, Cursor rule or Copilot instructions file and see which agents load it and which of its lines no agent enforces. Runs in the browser.
- [Shared team memory for AI coding agents](https://gethrbr.com/coding-agents): how Harbor gives Claude Code, Cursor, Codex and GitHub Copilot one memory of what the team decided, when the rules reach each agent, and how it compares with Supermemory, Cognee and Mem0.
- [Pricing](https://gethrbr.com/pricing): the three plans, every limit they enforce, what no plan meters, and the FAQ.
- [Contact](https://gethrbr.com/contact): reaches the people building it, not a sales team.
- [Terms of Service](https://gethrbr.com/legal/terms)
- [Privacy Policy](https://gethrbr.com/legal/privacy)
- [Data Processing Agreement](https://gethrbr.com/legal/dpa)
- [Refund Policy](https://gethrbr.com/legal/refund)

## Contact

hello@gethrbr.com