Scope Studio

Design the memory for your product in the customer portal, from a PRD, a repository, a website or a short brief, and get a handover pack your coding agent builds from.

Scope Studio designs the memory for a product or use case: what your product remembers, for whom, how clients are kept apart, who reads what and how long it stays. You give it what you have; it gives you the design and a handover pack that your coding agent builds from. Nothing is deployed until you choose to build it.

Open it from the portal's sidebar (Scope Studio).

Projects

Make one project for each product or use case. A project belongs to your company: everyone at your company can see it, add to it and run it.

Start a project in any of these ways:

Start from an example: marketing analytics, a support copilot, a team brain, memory for coding agents or an AI tutor. Each fills in a description you can edit.
PRD / files: drop a PRD or other documents.
GitHub: paste a public repository (or a folder in one). Reading it can take a minute.
Website: paste your site's address. Discovery follows its links when it needs more.
Describe: say what you're building, typed or spoken: who uses it, what it should remember, what must stay private. Messy is fine.

The project's name comes from what you give it. CortexHelper can also start a project from a conversation, with the conversation carried along.

What you can give it

Input	Limits
Files	PDF, Word (`.docx`), Markdown, CSV, JSON, text or images (PNG, JPEG, GIF, WebP), up to 25 MB each
A description	Up to 200,000 characters; upload anything longer as a file
Where it goes wrong	A real moment where your AI forgot or mixed something up: what happened, and what should have happened. Up to 20,000 characters each. These make the design much better.
A GitHub repository or a website	Read when you add it and kept as text

A project holds up to 20 inputs and 100 MB in all. One input is enough to start; more makes the design sharper. What you type is kept on your device until it is saved, so a dropped connection doesn't lose it. Leave out keys, passwords and personal data you don't need to share.

The three stages

1. Discover

Press Understand. Discovery reads everything you added, remembers it and writes up what it understood: the product, the problems memory has to solve and where memory would help. It takes about 2 minutes.

Added something later? The write-up says the material changed; press Update understanding so the design sees it.

2. Design

Design my memory first asks anything the write-up left open. Answer, and add any requirements of your own (for example "Keep each customer fully separate" or "Make deleting one person's data easy to prove"). The design then runs for 5 to 10 minutes; you can leave the page and come back.

The design covers where memory lives (the scopes), what is written and by whom, who reads it, what is asked of it, how long it stays, and why. To change it, describe the change and run it again: every finished design is kept, so you can go back to an earlier one.

3. Handover

When a design is ready, Handover gives you the pack and the prompt for your coding agent:

Download the pack.
Unzip it at the root of your project: your current repository, or a new folder if you are starting fresh. You get AGENTS.md and a cortexdb/ folder next to your code. If the project already has an AGENTS.md, add the new lines to it. For Claude Code, add the line @AGENTS.md to your CLAUDE.md.
Ask your agent to build it: open the project in Claude Code, Cursor, Codex or similar and paste the prompt from the page (Copy the prompt). It has the agent work through the plan in order and show you where the memory fits in your codebase before it writes code.

What's in the pack:

File	What it is
`AGENTS.md`	At the root: the CortexDB rules your coding agent loads every session
`cortexdb/README.md`	Start here: what the pack is and how to hand it to your agent
`cortexdb/BRIEF.md`	What you asked for: the product, the problem, what memory has to get right
`cortexdb/DESIGN.md`	The design, and why
`cortexdb/PLAN.md`	The build, task by task; each task says when it is done
`cortexdb/CONVENTIONS.md`	The project's rules for every memory call
`cortexdb/design.json`	The whole design, machine-readable; it wins if a file disagrees
`cortexdb/docker-compose.yml`, `cortexdb/.env.example`	CortexDB on your own server
`cortexdb/setup.sh`	Sets the design up on a new server: scopes, access and, where the design needs them, application tokens

Have these ready, because the agent will ask for them:

the CortexDB release and your company's license (portal, Releases);
an embedding provider key (an OpenAI-compatible API), or a local Ollama;
access to the data the product will remember, so the agent can build the pipeline and check the design on it.

Keys go in cortexdb/.env, which the pack's .gitignore keeps out of git.

From a coding agent

With an agent key, an agent connected to https://customer.cortexdb.ai/mcp can run Scope Studio itself:

studio_create_project with a name.
studio_add_input for each input: text in text, or a file in base64 with its filename and media_type.
studio_run to start designing (optionally with a comment).
studio_get_design every so often until the run is done; it then returns the design as JSON.

Projects made this way appear in the portal like any other, so you can review the design and download the handover pack there.