Getting started

getmyorg gives your coding agent an organization to work in: specialists for engineering, product, design, security and more, the standards they follow, and a live map of your repo they reason over. It runs in Claude Code and Codex.

getmyorg is in invite-only beta: anyone can install it, and signing in needs an invite.

Quickstart

  1. Install the plugin for your host (details in Install).
  2. Sign in. Run /myorg:login (Codex: $myorg:login).
  3. Set up a repo. From inside a git repo, run /myorg:init. It maps the repo, installs the git hooks that keep the map current, and builds the semantic map once.
  4. Look around. Run /myorg:brief for a summary in the terminal, or /myorg:hq for the dashboard in your browser.

If a step fails, run /myorg:doctor, and see Troubleshooting.

Before you start

  • Claude Code or Codex.
  • macOS or Linux. On Windows, use WSL2: install your host and getmyorg inside your WSL distribution.
  • curl and python3. The plugin uses them to install the getmyorg program the first time it runs. Both come with macOS and most Linux distributions.
  • A git repo to set up.

Install

  • Claude Code: /plugin marketplace add https://install.getmyorg.com/marketplace.json, then /plugin install myorg@getmyorg. Then turn on auto-update for the getmyorg marketplace (/plugin → Marketplaces); it is off by default. To update: /myorg:update. Restart Claude Code to load it. By hand: /plugin marketplace update getmyorg, then /plugin update myorg@getmyorg.
  • Codex: curl -fsSL https://install.getmyorg.com/install.sh | sh -s -- --host codex. It installs the getmyorg binary and the myorg plugin. To update: $myorg:update. Restart Codex to load it. Running the installer again also updates.

The first time the plugin starts, it installs the getmyorg program into ~/.config/getmyorg/bin/. You don't need a GitHub account or any repository access.

Added the getmyorg marketplace from GitHub before? Claude Code keeps one marketplace per name, so remove the old one first. Your sign-in and repo setup are kept.

  1. /plugin marketplace remove getmyorg
  2. /plugin marketplace add https://install.getmyorg.com/marketplace.json
  3. /plugin install myorg@getmyorg
  4. Restart Claude Code.

Sign in

Run /myorg:login. It opens getmyorg.com in your browser; sign in with the email your invite went to. Your sign-in renews itself, so you shouldn't need to sign in again in normal use.

Until you sign in, getmyorg offers only its sign-in tool. Once you're signed in the rest loads in the same session; if it doesn't appear within a few seconds, start a new session.

Then run /myorg:doctor. It checks the install and should end with OK — install is healthy.

Set up a repo

Run /myorg:init from inside the repo. It:

  • maps the repo: its modules, services, how they connect, and who owns what;
  • starts the semantic map, a description of what each part of the code does, written by your agent in the same session (first run only, and it says so before it starts);
  • adds the generated files to .gitignore;
  • installs git hooks that refresh the map as you work.

Everything lives in .myorg/ in your repo. Commit what /myorg:init leaves unignored: your team's rules and display settings are meant to be shared.

The semantic map is shared too. /myorg:semantic commands write it to .myorg/semantic-map.jsonl; commit that file with your change, or in its own pull request when you refresh on your default branch. When a teammate clones, pulls or switches branches, getmyorg loads it, so everyone works from the same map without running the model passes again. Risk records stay on your machine. To keep the whole map local, set semantic.commit: false in .myorg/config.yaml.

The hooks refresh the code map whenever you commit, switch branches, merge or pull. They run in the background, never block git, and keep any hooks you already have. To refresh by hand, run /myorg:refresh.

The semantic map is written by your agent, so the hooks only note that it's behind. Run /myorg:semantic refresh to bring it up to date; /myorg:priorities and the Guide page in /myorg:hq tell you when it's due.

The code map covers every file from the start. The semantic map fills in gradually: init charts the most connected code first, and a /myorg:semantic refresh with no new changes to process charts the next part, about three minutes each, until the map is healthy (about 60% of the code is charted, and no sizable area is left blank). /myorg:brief shows where you stand, for example All 591 code files mapped · 34% charted. To get there in one go, run /myorg:semantic refresh --chart: before it starts, it tells you roughly how long it will take and how many tokens it will use, and --chart --all charts the rest. To chart more per run, raise semantic.slice_input_tokens (and semantic.bootstrap_input_tokens for init) in .myorg/config.yaml.

Several repos that share rules

Rules are per repo by default. When a few repos should share them, put the repos in one folder, run /myorg:init in each, then run /myorg:init --org from that folder. /myorg:codify --org then writes rules every repo in the folder follows, and /myorg:brief org shows the whole org.

Read the map

  • /myorg:brief: a summary that fits in a terminal: stack, priorities, how the parts connect, and overall health. /myorg:brief priorities, health, recent and area <name> narrow it down.
  • /myorg:hq: the dashboard in your browser. It shows your product's features and their health, a map of the code, your org, and a Guide page with every command and what your repo still needs.
  • The status bar in Claude Code (/myorg:config statusline on adds it). It shows how much of the code is charted (▦ 99%), your folder, the model and its effort, how full the context is, and the one thing that needs you next. HQ's Guide explains each part.

Your agent groups the features on HQ's board. To keep a group of your own, run /myorg:semantic curate declare "<name>"; the next /myorg:semantic group fills it. /myorg:codify sets a group's importance and release stage, and /myorg:semantic curate renames, merges or moves things.

Each area of the code gets one recommendation:

RecommendationMeaning
StabilizeFragile or unhealthy: fix it before building on it
InvestA leverage point: work here pays off more than elsewhere
DocumentThe knowledge is in people's heads: write it down
DecomposeToo big or too tangled: split it up
MonitorNothing to do today, but worth watching

Work with your org

Run /myorg:dispatch <what you want done> to route a request through your org: the right lead picks it up and brings in specialists. /myorg:suggest proposes what to build next, and /myorg:triage sorts your open issues.

You get better results when you give each kind of work its own lane and ground requests in evidence: an issue link, failing output, an area of the map, a screenshot or a log beats "clean this up".

Teach it your rules

By default a new session remembers nothing from the last one. /myorg:codify writes down a rule, fact or preference that every agent sees at the start of every session.

/myorg:codify "always use snake_case"            # for the team: committed
/myorg:codify --local "prefer short answers"     # just for you: gitignored
/myorg:codify --org "prefer TypeScript"          # for every repo in the org
ScopeFileShared through git?
Team (default).myorg/team-instructions.yamlYes
Personal (--local).myorg/personal-instructions.yamlNo
Org (--org).myorg/org-instructions.yamlYes

When rules disagree, personal wins over team, and team over org. Codify checks each new rule against the ones you have: it spots duplicates, offers to merge related rules, and makes you resolve a contradiction before it writes anything. Nothing is written until you confirm.

Related commands:

  • /myorg:answer records the answer to a question that keeps coming up.
  • /myorg:override corrects what the map shows: an area's name, hidden areas, who owns what.
  • /myorg:learn reviews corrections from your sessions and turns the ones you approve into rules.

Commands lists every command.

Guardrails

The plugin checks your agent's shell commands, the files it reads and the edits it makes. Your agent works without interruptions on everyday commands, and getmyorg steps in on risky ones; how far depends on the level below:

  • Stopped: commands nobody should run by accident, like deleting your home folder, reading your SSH or cloud keys, or force-pushing main. The agent can't get past a stop; if the command is really needed, run it yourself with ! <command>.
  • Bounced back: risky commands like git reset --hard or a force-push to your own branch. The agent has to think it through before it retries.
  • A note to the agent: routine commands worth a second look, like a package install or git merge, a file that looks like a prompt injection, or an edit that hides an error instead of fixing it.

/myorg:config shows the level, and /myorg:config guards <level> changes it:

LevelWhat it does
strictOnly known-safe commands run without a second look.
guardedEveryday commands run, risky ones are stopped or bounced.
relaxedThe default: everything runs except never-OK commands and force-pushes to protected branches.
offThe guards do nothing.

The level is yours, not the team's: it applies in every repo you open, and /myorg:config guards <level> --repo sets one for this repo only, in a file git ignores. A copy of that file committed to a repo is ignored, so a repo can't change your settings. Only you can change it: the guards stop the agent from doing it.

Gate mode. If you turn Claude Code's own prompts off, by allowing Bash(*) or starting with --dangerously-skip-permissions, a command the guards don't recognise simply runs. /myorg:config gate on makes the guard ask you instead, in Claude Code's permission prompt, about every command that isn't routine: unrecognised ones, and risky ones that would otherwise only get a note or bounce back to the agent. The agent can't clear these prompts itself. /myorg:config gate off turns it off. Gate mode is Claude Code only: Codex's hooks can stop a command but can't ask you.

Codex

The Codex installer registers getmyorg with Codex and installs the myorg plugin. Codex has no plugin marketplace on the web, so the installer keeps the plugin in ~/.config/getmyorg/codex-marketplace. Check with codex plugin list. $myorg:update updates it to the latest release (so does running the installer again).

In Codex, getmyorg's commands are skills: type $myorg:init, $myorg:brief and so on, or pick them from /skills. /myorg:init is Claude Code's form.

Codex asks you to review a plugin's hooks before they run. Open /hooks and trust the myorg plugin's hooks to turn on the guardrails.

Get help

Docs for getmyorg v0.5.21.