Quickstart

The fast way: let your agent set it up

If you already work with Claude Code, Codex, OpenCode or another agent, give it this and it does the rest:

Set me up with kijito.ai.
Read https://kijito.ai/docs/quickstart and https://kijito.ai/llms.txt,
connect yourself to Kijito for every project, at user scope.
After I sign in, call kijito_startup, then kijito_onboard(action="start"),
and walk me through its steps one at a time. Tell me when you need
me to sign up, sign in, answer a question, or approve something.
If you can't reach kijito.ai and can't ask me for access, stop and
tell me what to change in your permissions.

Four things only you can do. Your agent will stop and ask you for each one:

1. Create the account. Sign up with an email and a password, and save the recovery codes you are shown.
2. Open the sign-in link and sign in again. Start the sign-in yourself, in your own agent app. In Claude Code, run claude mcp login kijito in your own terminal. If the link does not open by itself, Cmd-click or Ctrl-click it. It asks you to sign in even if you are already signed in on kijito.ai: that sign-in is what lets this agent into your memory, so it always asks. Don't let your agent run it for you and pass the link on: the link only works while the command that printed it is still running. (/mcp in a Claude Code session that was already open can't see Kijito yet: Claude Code loads a new server when it starts, so /mcp works after you restart it.) If your Claude Code says that command doesn't exist, restart Claude Code and run /mcp instead.
3. Answer the setup questions. Once you are signed in, your agent starts Kijito's setup checklist and asks one question at a time: first, one sentence saying what it may set up for you; then a name to file its work under.
4. Approve the setup steps. Your agent asks permission before it changes its own settings or installs anything. Say yes to the ones you want.

Everything your agent needs is public: this page, the setup map for agents, and two open-source add-ons it will offer to install:

• kijito-tools (described under Recommended): install with npx kijito-tools, then restart Claude Code so it picks them up. It registers its catch-up hook and a context statusline in ~/.claude/settings.json. For Codex, npx kijito-tools --provider codex --skills-only installs the three skills into ~/.codex/skills.
• kijito-inbox-monitor - wakes a running agent when another agent or a person sends it a message. Install: uv tool install kijito-inbox-monitor. This needs uv; if you do not have it, install it first with brew install uv or curl -LsSf https://astral.sh/uv/install.sh | sh. If you already use pipx, pipx install kijito-inbox-monitor works too. With kijito-tools 0.2.11 or later installed, your agent starts it and proves it wakes with ~/.claude/kijito-inbox-start.sh --persona <name>.

Prefer to do it by hand? The steps below are the whole setup.

1. Create an account

Sign up with an email and a password. Kijito is a free public beta: no card, and billing is off. Your memories are encrypted at rest under a key derived from that password, so save the recovery codes you are shown next. Until you verify your email the account holds up to 100 memories; the link we email you lifts that.

2. Connect your agent

Every client connects to the same address, https://api.kijito.ai/mcp, and there are two ways to authenticate:

• Sign in with your account - for you, at the keyboard. The client opens a browser, you sign in to Kijito, and the client keeps the session.
• An API key - for an agent that runs unattended, or in several processes at once. On your account page, under API keys, choose Create API key and name it. Four scopes are offered: memory.read (ticked for you), memory.write, memory.curate (correct and fade memories) and memory.dream (run dreaming). An agent that works the whole loop (recall, save, correct and fade, then dream) needs all four; tick them all unless you mean to limit it. Then Create key. The kjt_ key is shown once, so copy it then, and treat it like a password.

Claude Code

claude mcp add --transport http --scope user kijito https://api.kijito.ai/mcp

Or connect with an API key instead:

claude mcp add --transport http --scope user kijito https://api.kijito.ai/mcp \
  --header "Authorization: Bearer kjt_your_key"

Check it with claude mcp list, which reports ✔ Connected once the server is reachable and authenticated. Leave out --scope user to add Kijito to the current project only.

Claude desktop & Claude.ai

1. Open the profile menu (bottom left) and choose Settings.

   

2. In the left-hand list, under Customize, choose Connectors.

   

3. Choose + Add (top right), then Add custom connector.

   

4. Name it Kijito, paste https://api.kijito.ai/mcp as the MCP server URL, and choose Continue.

   

5. Keep the settings it detects: Authentication Sign in now, OAuth client Register automatically. Don't choose "Use Claude's published identity": Kijito doesn't support it. Then choose Add.

   

6. Your browser opens "Finish connecting a connector?": choose Continue connecting.

   

7. On Kijito's "Connect your memory" page, sign in, or tick This is a new account, create it. Leave all four permissions ticked and choose Connect.

   

8. When it says Connected, choose Open desktop app.

   

9. On the Kijito.ai connector page, under Tool permissions, set both Read-only tools and Write/delete tools to Always allow.

   

The Free plan allows one custom connector. On a Team or Enterprise plan, an Owner adds it under Organization settings → Connectors, then each member chooses Connect.

Codex CLI

Start Codex in your project folder and choose "Trust and continue" when it asks "Trust this folder?" (or "Yes, continue" if it asks "Do you trust the contents of this directory?"). If it does not ask, type /permissions and choose "Ask for approval": without that, Codex cannot reach the internet or ask you to let it.

Add the server in your own terminal. Codex detects that Kijito signs in with your account and starts the sign-in itself, so finish it there:

codex mcp add kijito --url https://api.kijito.ai/mcp

Codex may only print the sign-in link: copy it into a browser. It asks you to sign in even if you are already signed in on kijito.ai. Keep the command running until it says you are logged in, then start a new Codex session so the Kijito tools load. Run it yourself, not through an agent: the link only works while the command that printed it is still running. The Codex IDE extension and the Codex desktop app read the same configuration; restart them after adding.

If that sign-in lapses later, or add did not start it, run codex mcp login kijito. Or connect with an API key: put it in an environment variable that Codex starts with, and point the server at that variable.

export KIJITO_API_KEY=kjt_your_key
codex mcp add kijito --url https://api.kijito.ai/mcp --bearer-token-env-var KIJITO_API_KEY

codex mcp list shows the server as enabled, and names how it authenticates under Auth.

OpenCode

Sign in with your account:

opencode mcp add kijito --url https://api.kijito.ai/mcp
opencode mcp auth kijito

Or connect with an API key: add the server to ~/.config/opencode/opencode.jsonc and keep the key in your environment as KIJITO_API_KEY.

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "kijito": {
      "type": "remote",
      "url": "https://api.kijito.ai/mcp",
      "oauth": false,
      "headers": { "Authorization": "Bearer {env:KIJITO_API_KEY}" }
    }
  }
}

opencode mcp list shows ✓ kijito connected when it works.

3. Remember something

Start a new session so the client loads the Kijito tools. Ask your agent to begin with kijito_startup: in one call it loads who the agent is, what it did recently, and any active goals. Then give it something worth keeping:

Call kijito_startup. Then remember: we chose teal as the accent color for the Harbor project.

The agent calls kijito_remember and tells you the id of the new memory. One idea per memory recalls best.

4. Recall it in a fresh session

Close that session, open a new one, and ask:

What accent color did we pick for Harbor? Check Kijito.

The agent calls kijito_recall, which finds memories by meaning rather than by exact words, and answers from the memory it saved last time. That is the whole loop. Open Explore to see what it stored.

5. Watch it in Explore

Sign in on kijito.ai and open Explore. The overview counts your memories, the links between them, the themes they form and the agents that wrote them, and shows how recall has been used.

The Map tab draws the same account. At this level every circle is a theme, sized by how many memories it holds; click one, or zoom into it, to open its memories.

Keep going

• Concepts - how memories, edges, corrections, and dreaming fit together.
• Connect another client: Cursor, Codex, Gemini CLI and more, plus the REST API.
• FAQ & troubleshooting - when a client will not connect.
• Something broken or confusing? Send feedback - it goes straight to the people building Kijito.