projects

Project Workspaces

A project is one unit of work — a product, a client engagement, a piece of research, a house move — gathered into a single place. Conversations, tasks, documents, files, repositories, whiteboards, test suites, releases and support tickets all hang off it, and everything Ariadne needs to know about the work is written down once instead of being re-explained in every chat.

The part that makes it more than a folder is the charter: a short standing brief that Ariadne reads before every message in every conversation bound to the project.

Accessing Projects

Click Home → Projects in the top navigation, or go to /projects. Each project has its own address (/projects/your-project-slug) that you can bookmark or share with anyone who has access.

Creating a Project

1. Click New project
2. Give it a name
3. Write the intent — one paragraph, in your own words, describing what success looks like. This is the only field that really matters; everything else can arrive later.
4. Pick a starter charter: Blank, Web app, or Research. This just pre-fills the section headings with prompts appropriate to that kind of work.
5. Pick a scope: Personal, or one of the organisations you belong to. An organisation-scoped project is visible to that organisation's members.
6. Click Create

Nothing heavy is created up front. The note folder, charter document, whiteboard and file storage for a project appear the first time something needs them, so an unused project costs nothing.

The Charter

The charter is the briefing you would give a new colleague on their first day. Ariadne reads it before every chat about the project, so anything you put there it already knows — you stop repeating yourself.

It is written in sections, shown on the Overview tab in this order:

Keep it short. It is a briefing, not a manual — and it is competing for room in the agent's context on every single turn. If the charter grows past its budget, the lower-priority sections are dropped from the prompt rather than the whole thing being truncated.

Recording decisions

Below the charter is Record a decision: what was decided, and optionally why. Decisions are appended with the date and never overwritten. If you change your mind, record the new decision — the old one stays, so the reasoning is visible rather than silently rewritten.

The agent can do this too, with record_project_decision, so a conclusion you reach in conversation can be pinned without you retyping it.

The charter in a repository

For projects with code, the charter can be round-tripped to .ariadne/charter.md in the repository, so other tools and other agents can read the same brief. Ask the agent to export or import it — it uses sync_project_charter_file.

Stages

Each project carries a stage, changed from the dropdown beside its name:

Discovery → Shaping → Building → Shipping → Operating → Growing

The stage is a signal, not a workflow — nothing is gated on it. It tells the agent (and anyone looking at the list) what kind of help the work needs right now. The agent can move it with set_project_stage.

The Project Hub

A project opens on a tabbed hub:

Chats

Binding a conversation to a project is what puts the charter into that conversation's prompt. It is orthogonal to conversation type and channel — a Discord chat, a Code-mode session and a nightly autonomous run can all belong to the same project and all get the same briefing.

You can bind from either end: the Chats tab here, or the Project dropdown in a conversation's own properties panel.

One conversation is marked primary. That is the conversation other channels address when you say "talk to the project" from a voice call, Discord, or anywhere without a project UI — its id is shown on the Overview tab.

Canvas

Project documents are the same co-editing canvas used in chat: you and the agent edit the same text, every change is kept with who made it, and the agent can work on a document while you are elsewhere. Open one and the editor appears with a chat pane beside it, so you can say "tighten the second section" without leaving the document. See Chat & Conversations for how the canvas behaves.

Discovery

A discovery pass is Ariadne surveying the project and reporting what it actually has, rather than what you assume it has. Every finding carries the evidence behind it — a file, a passing test, a deployment — and anything that could not be verified is recorded as unknown rather than guessed at.

Ask the agent in the project's conversation to survey the project; it uses start_project_discovery. When the pass finishes it parks at awaiting review. Nothing changes the project until you tick the findings you want acted on and click Apply, which turns each accepted proposal into a work item.

Code

Register the repositories a project works on: remote URL, working branch, and whether it is the primary one. The checkout itself lives in the working directory of a connected Console or Desktop — Ariadne clones, scans and builds there, because that is the only place the code exists. What the project stores is where to find it and what state it is in.

Do not put a token or password in the repository URL. It would be stored and shown in tool results.

Setting a working branch matters: without one, the Code tab warns that agents should not be using the default branch.

Data

Connections defined on the project are available in every conversation bound to it, so you configure a database once instead of per chat. A single conversation can still define its own connection with the same name, and that one wins there.

Quality, Releases and Support

These three are one loop.

• Quality attaches test suites to the project and shows the latest run per suite, plus the cases that are failing, quarantined, or unproven (never shown to fail when the thing they cover breaks).
• Releases are cut with a version and an optional git ref. A release captures the work completed since the previous one at the moment it is cut, so what a release contained does not drift afterwards as items move around the board. States run Draft → Staged → Released, with Rolled back.
• Support counts incoming reports against the most recent release, because the question after shipping is whether shipping made things worse — not simply how many tickets are open. Tickets are attached from a conversation with route_support_ticket_to_project.

Timeline

Charter edits, decisions, stage moves, work transitions, deployments and support activity all land here as they happen, newest first.

Members and Access

Projects have members with roles, set on the Settings tab:

Agents can be members too, and are shown with a robot icon.

Moving a project into an organisation gives every member of that organisation access to its conversations, work and documents. Only the owner can change this.

Archiving and Export

Archive hides a project from the list. Nothing is deleted, and it can be restored from the same button.

Export produces the whole project as plain markdown and JSON — charter, documents, work, findings and releases — readable without Ariadne. The project is yours to take elsewhere.

What the Agent Can Do

Agents with the Base tool collection can work with projects directly:

For the project the conversation already belongs to, the agent does not need get_project_context — the charter is in its prompt every turn. That tool is for reaching a different project, or for pulling back a charter section that was dropped from the prompt for space.

Use Cases

• A product you are building – charter holds the decisions, Work holds the board, Code holds the repository, Releases and Support close the loop after shipping
• A client engagement – organisation-scoped, with the brief in the charter and every call's notes as project documents
• A research programme – the Research starter charter, Deep Research reports saved as project documents, and open questions tracked in the charter
• Anything with more than one conversation – the moment you find yourself re-explaining context to a second chat, that is a project