pieces.app

Pieces turns what already happened on your computer into a searchable memory, so you can ask questions about your own work, generate recaps and prep material from real context, and pick up interrupted work without retracing your steps. It's most useful if you work across many apps — email, chat, docs, meetings, AI tools, and code editors — and lose time reconstructing what you did, decided, or were about to do.

Ask anything about what you've already done

The core action is querying your own history instead of hunting through apps. Pieces captures a chronological timeline of your activity, and you can scope a prompt by time, source, or topic to find or curate exactly what you need.

That means questions like:

• "What did I decide about the pricing page last week?"
• "What was I working on before the meeting?"
• "Where did I leave the Figma review?"

Because the memory is formed from the apps you already use, the answers reflect your actual context rather than a summary you have to write yourself.

Generate recaps and prep in one click

Instead of manually assembling status updates, Pieces generates them from your real context. The site names these directly:

• Standup updates
• Morning briefs
• Meeting prep
• Day recaps

The practical value is turning "hours of retracing your steps" into a single click. If you spend the first 20 minutes of each day reconstructing yesterday, this is the workflow it targets.

Recover decisions and resume where you left off

Pieces is built to help you recover decisions and resume where you left off. When you switch between projects, tools, or days, the memory holds the thread: what was discussed, what was chosen, and what came next.

This is the difference between a note you remembered to write and a record that formed on its own. You don't need to have anticipated that a decision would matter later.

Feed real context into your AI tools

Pieces positions itself as a memory layer that brings real context into every AI tool. Rather than re-explaining your project, constraints, or prior decisions in each new chat, the memory supplies that background.

The site lists integrations across AI and work tools, including Claude, ChatGPT, Copilot, Codex, Perplexity, and Cursor — alongside email, chat, docs, design, and code editors. The point is that context follows you across tools instead of being trapped in one.

What gets captured

Pieces forms memories roughly every 2 seconds from the apps you use. Capture falls into a few categories:

Sources span Gmail, Outlook, Chrome, Arc, Safari, Slack, Teams, Google Chat, Discord, Google Meet, Zoom, Microsoft Teams, Google Docs, Notion, Figma, and the AI and code tools listed above.

Privacy and security as fundamentals

Pieces describes privacy and security as fundamentals rather than add-ons. Note the distinction in capture: what you see is captured by default, while copy-and-paste capture is opt-in only. If you're evaluating it for sensitive work, check the privacy details on the site before enabling broader capture.

Where to start

1. Install Pieces so it runs in the background on your computer.
2. Work normally across your apps for a day or two so a timeline forms.
3. Ask a scoped question about something you did — try filtering by time or source.
4. Generate a standup update or day recap and compare it to what you'd have written manually.
5. Connect an AI tool to see whether the added context changes the quality of its output.

Pricing and plan details are listed on the Pieces pricing page; check there for current terms rather than assuming a free tier.

Pieces runs in the background on your computer and forms memories every 2 seconds from the apps you already use, turning what already happened into a searchable timeline. It captures what you see in the currently focused application by default, with copy/paste capture and meeting/conversation audio as opt-in sources. You can then search, filter, and revisit any moment by time, topic, person, or tool — without changing how you work.

What Pieces captures, and when

The core mechanism is continuous background capture tied to the app in focus. According to Pieces, memories are formed every 2 seconds, which is what makes the timeline feel like a living record of your day rather than a set of manual notes.

Capture falls into three categories:

The distinction matters if you care about scope. Screen-level context is on by default; clipboard and audio are things you choose to include.

Which apps feed the memory

Pieces lists a broad set of supported apps and sources, grouped roughly by what they contribute to your timeline:

• Email: Gmail (threads, follow-ups, decisions, account context), Outlook (email history, commitments, meeting context)
• Browsers: Chrome (research trails, tabs, sources, web activity), Arc (web research, references, active project context), Safari (visited pages, research paths, useful sources)
• Team chat: Slack (threads, handoffs, decisions, open questions), Teams (chats, shared updates, calls, team context), Google Chat (conversations, asks, updates, decisions), Discord (community threads, feedback, support context)
• Meetings: Google Meet (decisions, action items, prep), Zoom (call takeaways, customer feedback, next steps), Microsoft Teams (meeting notes, chat context, project updates)
• Docs & design: Google Docs (drafts, comments, revisions, source material), Notion (project notes, specs, wikis, planning context), Figma (design reviews, comments, rationale, assets)
• AI tools: Claude (prompts, outputs, reasoning, reused context), ChatGPT (AI chats, drafts, summaries, task context), Copilot (code suggestions, edits, implementation context), Codex (agent activity, code changes, generated work), Perplexity (research answers, citations, source trails)
• Code editors: Cursor (agent work, code edits, commands, review context), VS Code (files, terminals, debugging, implementation trails), JetBrains (code navigation, edits, project context), Xcode (build context, app changes, debugging work)

The pattern is that Pieces plugs into the tools where decisions and context already accumulate, rather than asking you to move that work somewhere new.

How memories get organized

Captured activity is arranged chronologically into a searchable timeline. That structure supports a few concrete retrieval behaviors:

• Search and filter across any moment in your history.
• Scope prompts by time, source, or topic to find or curate exactly what you need.
• Ask about any time, topic, person, or tool — for example, "what did we decide about the Q3 launch?" or "what was I working on last Tuesday?"
• Generate recaps instantly from real context: standup updates, morning briefs, meeting prep, and day recaps.

The practical effect is that retracing your steps — which normally takes hours of scrolling through tabs, threads, and docs — becomes a single query against your own history.

What this means for your workflow

You don't have to adopt a new note-taking habit or manually file anything. Pieces works from the apps you already have open, so the memory layer builds itself as a byproduct of your normal day. The trade-off to weigh is scope: default screen capture is broad, while clipboard and audio are opt-in, so you control how much of your activity enters the timeline.

For pricing, plans, and platform availability, check Pieces pricing directly, since those details aren't covered here.

Pieces is an AI memory layer that runs in the background on your computer and builds a searchable record of your work as you go. It captures activity from the apps you already use — email, chat, browsers, docs, design tools, and AI assistants — so you can recover decisions, resume where you left off, and bring real context into other AI tools. It's most relevant if your work is spread across many apps and you regularly lose time reconstructing what happened or what you were about to do.

The core idea: memory instead of manual note-taking

Most productivity tools ask you to record things deliberately. Pieces works the other way around: it forms memories automatically from what you're already doing, then makes that record searchable and reusable.

According to the site, Pieces forms memories every 2 seconds from the apps you already use. That cadence is the point — the memory is meant to keep up with a normal working day rather than depend on you stopping to document it.

The stated purpose is to turn "what already happened" into "what you need to understand, do, or create next."

What it captures

Pieces organizes capture into a few categories, and the distinction matters because not everything is collected the same way:

The copy-and-paste channel being opt-in is worth noting if you handle sensitive text — that stream isn't on unless you turn it on.

The source list is broad and spans both work and personal tooling. Examples named on the site include:

• Email and messaging: Gmail, Outlook, Slack, Teams, Google Chat, Discord
• Browsers: Chrome, Arc, Safari
• Meetings: Google Meet, Zoom, Microsoft Teams
• Docs and planning: Google Docs, Notion, Figma
• AI tools: Claude, ChatGPT, Copilot, Codex, Perplexity
• Development: Cursor, VS Code, JetBrains, Xcode

For each, the site describes the kind of context captured — for example, Gmail yields threads, follow-ups, decisions, and account context; Slack yields team threads, handoffs, decisions, and open questions; Figma yields design reviews, comments, rationale, and assets.

What you can actually do with it

Three capabilities follow from having that memory:

Search and revisit any moment. The captured activity forms a chronological timeline you can search, filter, and revisit. You can ask questions about what you've done and scope the query by time, source, or topic.

Generate summaries from real context. Standup updates, morning briefs, meeting prep, and day recaps can be produced from your actual activity rather than from memory or guesswork. The site frames this as turning "hours of retracing your steps into one click."

Carry context across tools. Because the memory sits underneath your other applications, context can follow you between them — including into AI tools that would otherwise start from nothing.

Privacy and security

The site lists privacy and security as fundamentals rather than features. The concrete detail available is the capture model described above: focused-application capture is on by default, copy-and-paste capture is opt-in, and meeting capture comes from conversation apps and sources. If your work involves regulated or confidential material, that capture model is the first thing to evaluate against your own requirements.

Where it fits — and where it may not

Pieces is aimed at people whose work generates a lot of scattered context: researchers, engineers, designers, account and support teams, anyone living in meetings plus chat plus docs plus an AI assistant.

It's less obviously useful if your work already lives in one system with good native history, or if you can't have background capture running on your machine for policy reasons.

Two things the site references but this overview doesn't resolve: Pieces MCP and teams & enterprise offerings. If you need to connect Pieces to an MCP-compatible client or roll it out across an organization, those are the pages to check next, along with pricing at pieces.app/pricing.

Pieces describes privacy and security as fundamentals of how it works, and the main privacy control it states explicitly is that clipboard content is captured only with opt-in. Beyond that, the public product page doesn't spell out storage, encryption, or compliance specifics, so anyone evaluating Pieces for sensitive or regulated work should confirm those details in the official privacy and security documentation before rolling it out.

What Pieces captures, and what it doesn't

Pieces runs in the background on your computer and forms memories from the apps you already use, roughly every two seconds. The page breaks capture into three categories, and only one of them is opt-in:

The practical takeaway: screen context from your active app and meeting audio are part of the default memory stream, while clipboard content is not. If clipboard capture is the part you're uncomfortable with, leaving it off is the intended default state.

The scope of capture is broad

The list of supported sources is long and spans personal and work tools — Gmail, Outlook, Chrome, Arc, Safari, Slack, Teams, Google Chat, Discord, Google Meet, Zoom, Google Docs, Notion, Figma, Claude, ChatGPT, Copilot, Codex, Perplexity, Cursor, VS Code, JetBrains, and Xcode, among others. Each entry is framed around what gets remembered: threads and decisions, research trails, meeting notes and action items, drafts and revisions, prompts and outputs, code edits and debugging trails.

That breadth is the point of the product — it's what makes the memory searchable across time, topic, person, or tool — but it also means the privacy question isn't "does Pieces capture anything sensitive?" so much as "which of these sources do I want feeding a persistent memory, and how is that memory protected?"

What the page does and doesn't tell you

What it states:

• Privacy and security are treated as fundamentals, not add-ons.
• Clipboard capture requires opt-in.
• Context is designed to follow you across every tool.
• There are separate paths for Pieces MCP and for teams & enterprise.

What it doesn't state on this page:

• Where memories are stored (locally, in the cloud, or both).
• What encryption is applied at rest or in transit.
• Retention, deletion, or export controls.
• Compliance certifications or enterprise admin controls.

Those are exactly the details that determine whether Pieces is appropriate for a given team, so treat the marketing framing as a starting point rather than an answer.

How to evaluate it for your situation

If you're an individual trying Pieces for personal use, the opt-in clipboard setting plus a quick review of which apps you connect is a reasonable first pass.

If you're considering it for a team or regulated environment, work through these before committing:

1. Read the official privacy and security documentation and the team/enterprise materials linked from the site.
2. Confirm data residency, encryption, and retention terms in writing.
3. Check whether admin controls exist to restrict which sources can be captured org-wide.
4. Decide whether meeting and screen capture are acceptable for the roles involved, since those are on by default.
5. Verify how memories are deleted when someone leaves or a project ends.

The honest summary: Pieces is explicit that clipboard capture is opt-in and that privacy is a design principle, but the page-level evidence doesn't extend to the storage, encryption, and compliance specifics that most security reviews require. Get those from the official documentation, and treat any gap between the marketing language and the documentation as a question to resolve before deployment.

Pieces does have a pricing page — the site's navigation includes a "Pricing" link at pieces.app/pricing — so there is a commercial tier structure to check before you commit. The site also points to two distinct paths beyond the core product: Pieces MCP and Teams & Enterprise. That split is the clearest signal for how to choose: individual users evaluating the memory layer for themselves, versus teams and organizations that need shared or managed deployment. Exact prices, feature differences between tiers, and payment methods are not specified in the available site information, so treat the pricing page as the source of truth for those details.

What the site tells you about plan structure

From the homepage evidence, Pieces presents itself as "the memory layer for everything you do," running in the background on your computer and forming memories every 2 seconds from the apps you already use. Two entry points are surfaced for further exploration:

• Pieces MCP — positioned as a way to bring your captured context into AI tools.
• Teams & Enterprise — positioned for group or organizational use.

The presence of a dedicated Pricing link alongside these two paths suggests the decision isn't just "free vs. paid" but "which surface of the product you need." If you're a single user who wants your own work history searchable and reusable across AI tools, the individual path (and whatever the pricing page lists for it) is the relevant one. If you need multiple people working from shared context, or you're deploying inside an organization, the Teams & Enterprise path is the one to investigate.

How to decide which plan fits

Because the site doesn't publish tier-by-tier feature breakdowns in the material available, use your own usage pattern to frame the question, then verify against the pricing page:

The capture list matters here because it defines what "memory" actually covers on any plan. According to the site, Pieces captures what you see from the currently focused application, what you copy and paste (opt-in only), and what you hear and say from meetings and conversation apps. Supported sources named on the page include Gmail, Outlook, Chrome, Arc, Safari, Slack, Teams, Google Chat, Discord, Google Meet, Zoom, Microsoft Teams meetings, Google Docs, Notion, Figma, Claude, ChatGPT, Copilot, Codex, Perplexity, Cursor, VS Code, JetBrains, and Xcode. If a plan you're evaluating doesn't cover the sources you live in, the memory it builds will be incomplete regardless of price.

What to verify before choosing

The site states that privacy and security are treated as fundamentals, and that copy/paste capture is opt-in only. Beyond that, the available information doesn't specify data handling, retention, or regional storage details — so if those matter to your decision (especially for a team or enterprise purchase), confirm them directly rather than assuming.

Concretely, before you pick a plan:

1. Open pieces.app/pricing and note which tiers exist and what each includes.
2. Map your daily tools against the supported-source list above — a plan is only useful if it captures where your work actually happens.
3. Decide whether you need individual memory or shared team context; that choice routes you to either the core product or Teams & Enterprise.
4. Check whether Pieces MCP is part of the tier you want, since that's the bridge between your memory and external AI tools.
5. For anything involving a team, budget, or compliance, contact the vendor — the public page doesn't carry enough detail to decide those cases alone.

The short version: yes, there's a pricing page, and the real decision is individual versus team/enterprise plus whether MCP access is included. Get the numbers and feature list from the official pricing page, since they aren't published in the material summarized here.