How projects keep your AI work organized

A project is a folder for your AI work, with opinions. "Create Project" on the Dashboard gives you a place to group related conversations, and past a dozen or so chats you'll want one: a flat conversation list stops scaling right around the day a client brief, a side experiment, and a half-finished draft end up three scrolls apart.

Projects inside projects

Most AI tools give you one level of project and stop there, which works right up until the day one project turns into six. GPTree projects nest. When you create a project, the form has an optional "Parent Project" field, and picking one puts the new project inside it. Do that again and you have a third level. Keep going as deep as your work actually goes.

The Dashboard shows the hierarchy as an expandable tree, so a client engagement can hold a project per workstream, a research program can hold a project per study, and a big launch can hold discovery, drafting, and review as separate compartments under one roof, each with its own conversations and its own briefing. Nothing about that is fixed either: open any project's settings and change its parent, and the project moves, conversations and all. (You can't move a project underneath one of its own children, which is the one rule the tree enforces.)

Nesting is a hierarchy for organization, not a broadcast channel. Instructions and reference files live on the project you attach them to; a sub-project doesn't automatically inherit its parent's brief. Memory does something smarter, described below.

Grouping is the obvious half. The less obvious half is that a project briefs the model.

A folder that briefs the model

Projects hold instructions and reference files that the AI uses. Drop the style guide or the product spec into the project once, write the standing instructions once, and every conversation inside starts already oriented. You stop opening each new chat by re-pasting the same three paragraphs of context, because the project carries them for you.

Reference files matter more than people expect. A long spec pasted into a chat scrolls away; the same spec attached to the project is simply present, for every conversation in it, including the branch you'll create three weeks from now.

Project settings (the gear icon) go further: set a default model and a persona for the project, and attach files there too. Your writing project can default to the model and voice you trust for prose while a code project defaults to something else entirely, and that per-project default quietly removes a decision you were making dozens of times a week.

Memory is scoped the same way, and this is where the hierarchy pays off. What GPTree remembers can live at project scope, so facts and decisions learned inside one client's project don't wander into another client's conversations. Inside a project tree, recall widens on purpose: a conversation in a sub-project can draw on what was learned in its parent and sibling projects, with the current project's own memories floating first, and the Memory Inspector labels where each remembered fact came from. So the client engagement at the top of the tree accumulates knowledge that every workstream underneath it benefits from, while a different client's tree stays a different room. (What memory is, and how to inspect and edit it, is its own article.) For consultants, or anyone running parallel clients, we think this scoping alone justifies projects.

Projects are the unit of sharing

On the Team plan you can invite specific people to collaborate on a project, and sharing a project shares its documents along with it. Collaborators come in two roles: viewers can read, editors can send messages and branch. Everyone works from their own account, on their own plan and credits, so there's no shared billing to untangle.

When you don't need a project

A one-off question doesn't need a folder, let alone standing instructions. Just chat. These all go into the "Random" folder to keep your workspace clean.

And for a question you'd rather not have remembered at all, a temporary conversation fits better than any project: it saves no memories and deletes itself after 24 hours of inactivity.

Projects sit one level above everything else in this section. Branching, comparing, and merging all happen inside a conversation; a project is where related conversations live and share context without leaking into each other.