---
title: "Why we're building Spool"
description: "Software starts as a conversation and ends as a release, and the why gets lost in between. Here's what we think should change, and what Spool does about it."
date: "2026-11-16"
tags: ["Vision", "Product"]
---

> Documentation Index
> Fetch the complete documentation index at: https://spool.team/llms.txt
> Use this file to discover all available pages before exploring further.

# Why we're building Spool

Every software project starts the same way: someone explains what they need. A client on a call, a product lead in a planning meeting, a support thread that keeps coming back. That conversation holds the most important thing a team will ever know about the work: **why** it matters.

Then the work starts moving. Someone writes notes. Someone turns the notes into a requirements doc. Someone turns the doc into tickets. A developer picks up a ticket weeks later, and a tester checks it after that. At every step, a little of the why falls away. By the time the work ships, the reason behind it lives only in someone's memory, if it lives anywhere at all.

We spent years delivering software this way. Spool is what we wish we'd had.

## The tools aren't the problem. The gaps are.

Most teams already use good tools. A tracker for tickets, a wiki for docs, a notetaker for meetings, a drive for files, a chat app for everything else. Each one is good at its own job.

The trouble is the space between them:

- **Context gets copied by hand.** A decision from a call is retyped into a doc, then summarised again in a ticket. Each copy is a little less accurate than the last.
- **Links rot.** A ticket points at a doc that moved. A doc points at a recording nobody can find.
- **"Why are we building this?" has no home.** The answer is usually in a call from three weeks ago, and only one person was on it.
- **AI arrives as a button.** Each tool adds its own assistant, and each assistant only sees its own corner of the project.

None of this is anyone's fault. It's what happens when a project is spread across tools that were never meant to share what they know.

## One place for the whole project

Spool brings the work together. Meetings, requirements, files and work items live in one place, and they stay linked to each other.

A client call is recorded and turned into notes, with the decisions pulled out. The requirements doc is drafted from that call, and every version is kept. The work items that come out of it remember where they came from, so anyone can open an item and follow it back to the moment it was agreed.

That one idea, that **every piece of work keeps its origin**, changes a lot:

- A developer doesn't have to ask what the client meant. The quote is one click away.
- A new teammate can catch up on a project by reading it, not by booking calls.
- A tester can check work against what was actually asked for, not a paraphrase of it.
- When someone asks "why did we do it this way?", there's an answer, with a source.

## Agents that work like teammates

Once the whole project is in one place, an agent can actually be useful. Spool, the agent, has read the same meetings, docs and items your team has. You can ask it anything about the project and get an answer that points to where it came from.

You can also hand it work, the way you'd hand work to a teammate. Assign it an item, mention it in a comment, or ask it directly. Small things happen right away. Bigger things come back as a draft for a person to review. When it needs a decision, it stops and asks.

Two rules make this safe:

- **People stay accountable.** An agent can take on real work, but a person reviews what it produces, and risky changes always wait for someone to approve them.
- **Agents respect permissions.** An agent never sees or does more than the person it's working for. If you can't see a client's project, neither can the agent you asked.

## Built for teams that work with clients

A lot of software is built by teams working for someone else: agencies, consultancies, and companies running several products at once. They need each client's work kept apart, and they need to share the right things with the client without exposing everything else.

In Spool, each client or product gets its own team. Private teams stay private, in search and in the agent's answers too. Clients can join as guests and see only their own work, and docs can be published to them when they're agreed, not while they're still being argued over.

## What we believe

A few principles guide every decision we make:

- **Everything is connected.** Any piece of work should trace back to the conversation it came from.
- **One project brain.** If it's part of the project, you should be able to ask about it and get a sourced answer.
- **Simple over complex.** Workspace, team, project. Power should come from agents, not from setup screens.
- **Agents are teammates, people are accountable.** Agents do the work in between. People decide what ships.
- **Honest by default.** We show what's ready and say what isn't.

## Where we're going

Today, Spool covers the start of the journey: meetings, docs and files, work items and sprints, with the agent working across all of them. Next, the same thread runs further: into code and pull requests, into tests written from acceptance criteria, and into a map of the whole project you can explore.

The goal hasn't changed since the first day: **from the first conversation to a tested release, with nothing lost along the way.**

If that sounds like the way you want to work, [request access](https://spool.team/request-access/). We're onboarding teams now, and we'd love to hear what you'd want Spool to do next.

Source: https://spool.team/blog/why-we-are-building-spool/index.mdx
