Set up your agent

Set up your agent for a project

Elliptic is Jira for your agents, and this page is how you let one in. It wires a single project so your AI coding agent, Claude Code, Cursor, Claude Desktop, or any MCP client, reaches for the company-brain MCP whenever it looks something up or writes something down about your work. The agent becomes a first-class operator of the same projects, tasks, meetings, and notes your team uses, acting on your organization's own model key (BYOK).

Setup is per project and opt-in. You wire only the directories where you want Elliptic in the loop, and every other project on your machine stays exactly as it was. The whole thing is one command, and it is safe to run again whenever you like.

One-command setup

From the root of a project you want connected, fetch the setup script, read it, and run it. It is a small, plain bash script with no dependencies beyond a shell, so reviewing it before you run it takes a moment.

# from the root of a project you want connected
cd your-project
curl -fsSL https://elliptic.sh/elliptic-agent-init.sh -o elliptic-agent-init.sh
bash elliptic-agent-init.sh

The script prints the project it is wiring, the MCP endpoint it will point at, and the server name it will use, then writes the three files described below. It only ever touches the directory you run it in.

Flags

Two flags let you override the defaults. You will rarely need them on the hosted instance, but they matter for self-hosting or for running more than one workspace side by side.

# point at the hosted instance explicitly
bash elliptic-agent-init.sh --endpoint https://api.elliptic.sh/api/v1/mcp

# or set it once in the environment
export ELLIPTIC_MCP_URL=https://api.elliptic.sh/api/v1/mcp
bash elliptic-agent-init.sh

What gets written

The setup writes three small, readable files. Together they tell your agent that this project has a company brain, how to reach it, and when to use it. You can open all three and see exactly what was added.

1. .mcp.json, the connection

At the project root, .mcp.json declares the Elliptic MCP server as an HTTP transport pointing at the endpoint. Authentication is OAuth, so the file carries the URL and nothing secret. No API key and no token is written to disk. The agent obtains a token through a browser consent the first time it connects.

{
  "mcpServers": {
    "elliptic": {
      "type": "http",
      "url": "https://api.elliptic.sh/api/v1/mcp"
    }
  }
}

If a .mcp.json already exists and already defines a elliptic server, the script leaves it alone. If the file exists without that server, the script will not edit it for you, to avoid corrupting your config. Instead it prints the exact server entry to paste into your existing mcpServers object.

2. The Elliptic block in CLAUDE.md, the routing rule

The script adds a marked Elliptic (company brain) block to CLAUDE.md, the file your agent reads as project instructions. The block is wrapped in <!-- elliptic:start --> and <!-- elliptic:end --> markers and is fully idempotent. Re-running drops the old block and appends a fresh one, keeping everything else in the file in place. The block tells the agent three things.

• Search first. Before answering anything about the company, a project, a task, a person, a meeting, or a deadline, query Elliptic (mcp__elliptic__*) instead of guessing or relying only on local files.
• Save there. When asked to create or track work, a task, note, decision, or follow-up, write it to Elliptic, not just to local memory.
• It is authoritative. Treat Elliptic as the source of truth. Local memory and notes should point to it, not duplicate it.

The block closes by reminding the agent to authorize once with /mcp. If you keep your project rules somewhere other than CLAUDE.md, the same prose works pasted into that file.

3. SKILL.md, the on-demand skill

The script writes .claude/skills/elliptic/SKILL.md, a skill the agent loads on demand rather than keeping in context all the time. Its description triggers whenever you ask to find, search, look up, check the status of, create, update, or save anything about the company, a project, a task, a meeting, a note, a person, or a deadline, and routes those requests to the company brain. Inside, it maps the request to the right tools so the agent does not have to guess.

• Start from a list or search tool, then drill in: list_projects, list_project_tasks, get_task.
• Create and move work with create_task, update_task, transition_task_status.
• Capture thinking with create_note and list_notes, and read schedule context with list_meetings and list_calendar_events.
• Catch up or resume with brain_changes_since, brain_open_threads, and brain_resume.
• Reuse an idempotency_key on creates so a retry never duplicates the item.

Authorize once

The files declare the connection, but no credentials live in them. The first time your agent connects, it walks an OAuth consent in your browser and stores the resulting token itself. You do this once per project.

1. 1
   Open the project

   Open it in Claude Code (or your MCP client). It detects .mcp.json and offers to approve the elliptic server.
2. 2
   Run /mcp and approve

   Run /mcp and approve elliptic. The client kicks off the OAuth flow and opens the Elliptic consent screen in your browser.
3. 3
   Pick a workspace and grant access

   On the consent screen, choose the workspace you want the agent to act in (or All my organizations for a cross-org token, when your account can grant one), then approve the permissions. Tick Root / Admin to grant the full tool surface in one step, or hand-pick scopes to keep the agent narrow. Some baseline scopes are always on and cannot be unchecked.
4. 4
   Done

   The client stores the token and reconnects. Your agent now reaches for Elliptic on project search and save in this project, and nowhere else.

Other clients and manual setup

The script only writes the three pieces above, so you can wire any MCP client by hand. This is the path for Cursor, Claude Desktop, and other clients that read their own project config and rules files. The connection and the routing rule are the two things that matter, the skill file is a Claude Code convenience.

The connection

Cursor reads a project .cursor/mcp.json (or a global ~/.cursor/mcp.json), and most clients accept the same shape. Point any of them at the endpoint and complete the browser consent on first use.

{
  "mcpServers": {
    "elliptic": {
      "url": "https://api.elliptic.sh/api/v1/mcp"
    }
  }
}

Claude Desktop and clients that do not yet speak OAuth-protected HTTP natively can bridge through mcp-remote. The full per-client install steps, including the Cursor deeplink and the bridge config, live on the Company-Brain MCP page.

The routing rule

Paste a Elliptic block into the client's project rules file (CLAUDE.md for Claude Code, your project rules for Cursor, and so on). The wording matters less than the three instructions: search first, save there, treat it as authoritative.

## Elliptic (company brain)

Elliptic is the source of truth for this org's projects, tasks, meetings,
notes, calendar, and activity.

- Search Elliptic (`mcp__elliptic__*`) before answering anything about the
  company, a project, a task, a person, or a deadline.
- Save tasks, notes, decisions, and follow-ups to Elliptic, not just locally.
- Treat it as authoritative. Local memory should point to it, not duplicate it.

Authorize once with `/mcp`.

On Claude Code you can also add the optional skill at .claude/skills/elliptic/SKILL.md whose description triggers on project search and save and lists the mcp__elliptic__* tools, exactly what the script writes.

Memory, not duplication

The point of all this is one source of truth. Let Elliptic hold the data and have your agent's local memory point to it rather than copy it. When the brain is authoritative, you never have to reconcile a stale note against the real task, and any agent or teammate who opens the workspace sees the same current picture.

The reverse direction: outbound connectors

This page wires your agent to pull *from* and push *into* Elliptic. The opposite is also available: letting Elliptic reach *out* to the tools your work already lives in. An admin can add outbound MCP connectors under Settings → Connectors, choosing from a curated catalog (GitHub, Linear, Notion, Sentry) or pointing at any custom HTTP or SSE MCP server. Each connector's credential is encrypted at rest, and a test action connects to the remote server and lists its tools so you can confirm it works before relying on it. The Marketplace tab next to it gathers connectable apps, agents, and importers in one place.

Use the two directions together: this setup makes the company brain your agent's memory, and outbound connectors let that brain act across the rest of your stack, all on your organization's own keys.