Full transcript lightly edited for readability
**Projects overview (00:00).** Projects bring almost everything you can do in SecondStack into one place: chats, knowledge, memories, project files, and team access. I'm Andrew from SecondStack, and today I'll show you how the Projects feature works and why it's useful.
**Creating a project (00:18).** First off, I want to show you how to create a new project. I just click this button, and first we have to give the project a name. Next, we can add project instructions and a description. This is very important and useful, because these instructions will be added to every chat in this project. Then we can manage access — we can manage who can read this project or contribute, like particular people, teams, or groups. I've already prepared a project for this demo — Analytics Dashboard — and I added some chats, documents, decisions, and images in advance.
**Exploring the Project Hub (01:00).** Now let's take a look at the project page. To do that, we click this button here. This is the main page of the project. Here we can start a new project chat, look at the threads, and manage knowledge collections, project memories, the gallery, or project settings.
**Knowledge and Project Settings (01:43).** Let's look at the Knowledge page. You can see that I added some product files, and the main thing we should know is that these files are available across all projects. It means we don't need to reattach these files in every new thread — we can start a new thread with these files already there. We can also link a knowledge collection and use external knowledge collections from the Knowledge Collections page. Now let's take a look at the Project Settings page. On this page, we can configure the project: change the name and the project instructions, and customize the project appearance with different icons and colors. We can also change the model for new threads, manage MCP connectors and agentic sandboxes, and manage notifications and project access.
**Working across project chats (03:00).** Now let's look at the project's Threads page. Here we can find particular threads, and we can start a new thread. Now I want to show you the key benefit of using the Projects feature. I prepared a prompt where I ask the model to prepare an update using information from different threads and knowledge collections. Let's run it. And we get the answer — the answer is here. As I said earlier, the model can search across different threads and different files in a particular project. Let's review how the model interacted with these files. We can see that the model searched the files in the knowledge collections, and it also used project thread search to find the information we asked for. We can expand this block and see the query it used to find this information. As I said, this is the main value of the Projects feature: a project chat just doesn't have to start from scratch — it already has all the context you need in a new chat.
**Project Memories (04:50).** Now I want to show you how project memory works. To do that, I'll copy this text and ask the model to store it as a record in project memory. So let's do that. I can see that the model stored the memory successfully — we can confirm it here. Let's move to the project page and open the Project Memories page. Here we can see that the model stored our memory records, and we can manage them here — delete something or change some memories.
**Gallery (05:45).** Now I'd like to say a couple of words about the image gallery page. On this page we can find all images uploaded to threads or generated inside threads in the project. This is very useful when we want to find a particular image. This page works exactly the same as the general Image Gallery page, but it's always scoped to the project.
**Access and collaboration (06:30).** Last but not least: access. Here we can manage who can read, contribute to, or manage this particular project. It means we can grant access to individual users, teams, or groups. We can also let them change the knowledge, memories, or project settings. This is very useful, because you and your teammates can work in the project with the same context. All right, that's basically it — this was a quick look at Projects and how different parts of SecondStack can work together inside one project. Feel free to ask questions and leave comments. Thank you for watching, and see you in the next tutorial. Bye.
## Creating a project
Creating a project asks for three things. Everything else can be set later in Project Settings.
- **Name** — how the project appears in the sidebar and breadcrumbs.
- **Project instructions and description** — a prompt attached to the whole project. As the in-product help puts it: "Describes this project to the model. Added to every chat in this project, after the model and personality prompts."
- **Access** — who can contribute to or manage the project: individual people, teams, or groups.
Standalone threads don't go away. A thread is project-scoped only when it belongs to a project, and one-off chats keep working exactly as before.
## The Project Hub
The sidebar gives you compact navigation — projects with expandable thread lists. The **Project Hub** is the project's main page, with a **New project chat** action and five tabs:
- **Threads** — the project's conversations.
- **Knowledge** — linked collections and Project Files.
- **Project Memories** — the project's stored memory records.
- **Gallery** — images from across the project's threads.
- **Project Settings** — shared configuration plus your personal notification preferences.
## Knowledge in a project
The Knowledge tab holds the documents the whole project can draw on — you upload once instead of reattaching files in each new chat. It has two zones:
- **Linked collections** — references to existing shared [Knowledge Collections](/features/knowledge-collections/): "Reference shared knowledge collections to make them available to every thread in this project."
- **Project Files** — files uploaded straight into the project, stored in a hidden collection the project owns. While it holds files, the composer shows a **Project Files** indicator that links back to the Knowledge tab.
The project's files are listed for the model in every project chat, and it reads or searches them on demand — their contents are not pre-injected into each message. Project chats always draw on the project's knowledge rather than on per-chat file attachments.
Project Files behave like a store the whole project shares: any participant can add files, while removing one requires Manage permission. The project's own file store is private to that project — it stays out of your Knowledge Collections list and no other project can reach it. Linked collections work the other way round: they stay independently owned, can be linked into more than one project, and project membership only lets members use them inside this project's chats.
## Project Settings
Project Settings collects everything shared about the project:
- **Name and instructions** — the same fields you set at creation.
- **Project appearance** — an icon and a color from a fixed catalog; the color tints the composer and your messages in project chats, so you always know which project you're in.
- **Model for new threads** — "Choose a shared starting model. If unset, each member's last-used model is used."
- **MCP Connectors and Agentic Sandboxes** — which MCP connectors and [SecondAgent](/features/ai-agent/) skills run in this project's chats.
- **Notifications** — personal notification preferences for the project's threads.
- **Access** — the project's permission grants (covered below).
Managers change the shared settings; everyone else sees them read-only, though personal notification controls stay editable. Shared fields autosave one by one — except Access, which is an explicit **Apply access** action because it can widen permissions. Deleting a project deletes the project and every thread inside it, and the confirmation dialog makes you type the project name.
## Working across project chats
This is the core value of the feature, and the video's key demo. A chat inside a project gives the model project-scoped tools:
- **Project threads search** — find messages in the project's other threads.
- **Project threads list** — enumerate the project's threads by recent activity.
- **Thread summarize** — get a bounded summary of one thread.
- **Knowledge retrieval** — query Project Files and linked collections.
In the demo, one prompt asks for a status update drawing on several threads and the project's documents. The model answers by searching both the project files and the other project threads, and each tool call appears as a step in the answer — expand it to see the exact query the model ran. Every tool is scoped to the current project and re-checks the sender's access.
The project instructions ride along too: the system prompt is layered as the model's system prompt first, then the thread owner's personality prompt, then the project description. The net effect is that a new project chat doesn't start from scratch — the context is already in place.
## Project Memories
Project memories are explicit records, not hidden prompt side effects. You can create, edit, delete, and filter them in the Project Memories tab, and each record shows its indexing status.
- **The model can write them** — ask it to remember something, as in the video, and it stores a record you can then confirm and manage in the tab.
- **Project threads recall them** — as the product puts it, "Project memories can be searched and recalled by project threads." On the first message of a project thread, relevant personal and project memories are retrieved and injected as visible context steps — matching project records appear as a "Project Memories Found" step. Later turns use memory tools explicitly; there is no hidden injection.
- **Ownership follows access** — contributors edit and delete their own project memories; managers administer the whole list and can retry failed indexing.
Personal memories are separate: they live in Settings → Memories and belong only to you.
## Gallery
The Gallery tab collects generated and uploaded images from across the project's live threads, with the same all / generated / uploaded filters as the main [Image Gallery](/features/image-generation/) — just always scoped to the project. Useful when you remember the image but not which thread it came from.
## Access and collaboration
A project has two permission levels:
- **Contribute** — "Can read project threads, send messages, and use project knowledge and memories."
- **Manage** — "Can change project settings, access, knowledge, memories, and deletion."
Reading comes with Contribute, so everyone you add to a project is a working participant — they can open and resume every live thread in it.
Grants go to individual people, teams, or groups, where teams and groups come from the [ControlTower](/features/controltower/) membership directory. The project owner always has Manage. Platform admins can additionally share a project with all users, which grants everyone Contribute.
Projects run on the same self-hosted platform as everything else in SecondStack, and project chats count against the same [budgets and usage analytics](/features/cost-management/) as any other chat.
### Sharing resources through a project
If you attach a resource that some project members couldn't otherwise reach, SecondStack shows an acknowledgement dialog — "Share these resources through the project?" — before applying the change. The implied access is bounded: participants can use the resource inside this project's chats, but the resource's own access settings are unchanged and it never becomes independently visible or manageable elsewhere.
### Personal vs. shared state
Pinning or hiding a project affects only your own sidebar. Pinning a thread inside a project is shared — the whole project sees the same pinned order.
## Related
- [SecondChat](/features/chat-app/) — the chat workspace projects live in.
- [Knowledge Collections](/features/knowledge-collections/) — the shared collections you can link into a project.
- [Image Generation](/features/image-generation/) — the images the project Gallery collects.
- [SecondAgent](/features/ai-agent/) — the agentic sandboxes you can enable per project.
- [Cost Management](/features/cost-management/) — the budgets and analytics project chats count against.