Ask what changed.
Get the update
with receipts.
Timeline captures work from Slack, meetings, docs, email, code, CRM, and internal tools, then writes cited updates, handoffs, digests, and answers automatically.
CAPTURE ONCE · ANSWER OFTEN · CITE EVERYTHING
Client context, decisions, promises, and delivery updates without Friday archaeology.
Project memory across kickoff calls, customer Slack, docs, issues, and launch tasks.
What shipped, what blocked, and what changed without chasing every owner.
Investor, customer, and team answers from the work already happening.
Teams do the work, then separately report that the work happened.
Someone reconstructs reality by hand.
- Search Slack, docs, meeting notes, tickets, and CRM.
- Ask three people what changed and what was promised.
- Rewrite the same update for clients, leadership, and teammates.
The answer is generated from evidence.
- Capture the work where it already happens.
- Ask a project, client, or status question in plain English.
- Share a cited answer with links back to the source events.
The result is predictable. CRMs, trackers, and wikis drift because they depend on people re-entering reality after the fact. Half the team's decisions live in threads no one can find. When someone asks “what changed with Acme?” the honest answer is “let me check with three people.”
The Timeline inverts it: capture work as it happens, then generate communication and memory from the evidence.
Start with one real project: connect the channels and calls, let Timeline capture a week of work, then ask for the update. The answer becomes the entry point to project and client state: current, queryable, cited, and approval-backed.
Voice memos, text, files, team groups, and /ask all land in the same cited history.
DMs, bound channels, files, slash commands, and thread replies become searchable memory.
Meeting bots join calls, transcribe discussion, and extract decisions, tasks, and summaries.
Forwarded mail, CCs, BCCs, scheduled work, and time-aware context sit beside chat.
GitHub, Linear, Drive, Monday.com, Slack workspace history, and Sentry sync into cited events.
Typed notes, audio uploads, drag-drop files, approvals, and cited agent chat.
Versioned folders keep uploads, edits, and document history queryable with source links.
First-party connectors and MCP servers extend Timeline into SaaS and internal systems.
Keep the stack. Let Timeline collect the evidence around it.
GitHub, Linear, Google Drive, Monday.com, Slack workspace history, and Sentry are native integrations: PRs, issues, docs, board updates, channel decisions, errors, and releases become cited events. Connect chat, meetings, docs, code, support, CRM, and internal tools. Timeline turns the work already happening there into cited updates, digests, handoffs, and answers. Long-tail systems plug in as MCP servers; those systems become durable timeline events only when paired with native sync or custom ingestion.
Slack
Telegram
Email CC
Google Meet
Teams
Zoom
Drive
Notion
Linear
GitHub
Jira
Salesforce
Pipedrive
HubSpot
Figma
- “What shipped in last week’s releases?”
- “Which launch board records changed this week?”
- “What did the team decide about pricing in #leadership last week?”
- “What broke after yesterday’s deploy?”
Need an internal tool? Connect any MCP-compatible server under team settings.
Ask what changed. See the receipts.
Every fact resolves to a raw event: voice memo, Slack or Telegram message, email, document version, with author, timestamp, and source. Click the chip; the inspector shows exactly what was said.
Re-run the extraction with a better model tomorrow — the raw event never changes, the citations always resolve.
- Raw events are immutable.
- What was said goes in as-is and never changes. Derived facts are regenerable; the source is sacred.
- Privacy is per-event, not per-team.
- A brain dump can stay private even inside a team channel. Visibility lives on the event.
- Team-scoped end to end.
- Every query, every vector, every byte carries a team_id. Enforced at the data layer, not the UI.
- One inference layer.
- Chat, embeddings, transcription — all through a single provider abstraction. Embedding model is pinned for index integrity.
What is The Timeline?
The Timeline is an evidence-derived operating record for teams. It can show up as a Slack or Telegram bot, join calls to take notes and transcribe meetings, ingest forwarded emails and document uploads, and compile the event history into updates, digests, handoffs, answers, and project or client memory. Every answer the agent returns is cited back to the raw event it came from.
Who is The Timeline for?
Small to mid-sized teams doing work where context loss creates client risk, delivery drag, or leadership noise: agencies, consultancies, implementation teams, account success teams, product teams, and founder-led operations. The kind of team where one person being out of the loop on a client or project conversation creates real friction.
How is The Timeline different from a CRM, wiki, or ticket board?
Existing tools punish recording. CRMs require the contact, deal stage, and next step before you can log a single sentence. Wikis demand a page hierarchy. Ticket boards demand a project and status. The Timeline inverts this: capture is unstructured, output is structured. The agent extracts objects (people, companies, projects, deals, tasks, documents), facts, relationships, and changes from raw input, then proposes approval-backed state only when the evidence is durable.
How is capture done?
Work surfaces feed one pipeline. Telegram and Slack bots capture chat, voice, files, /ask, and @Timeline context. Meeting bots join Google Meet, Zoom, and Microsoft Teams calls to take notes and transcribe discussions. Email, documents, calendar events, web notes, project tools, code systems, support queues, account systems, and internal tools can become part of the same evidence model through capture surfaces, integrations, and ingest webhooks. GitHub, Linear, Google Drive, Monday.com, Slack workspace history, and Sentry sync as native integrations. MCP servers extend the agent into long-tail systems for live access, and successful tool results are captured as private evidence for later reconciliation.
What models power the agent?
Chat, embeddings, and transcription run through OpenRouter via a single inference abstraction (llm.chat, llm.embed, llm.transcribe). Chat models are swappable per task. The embedding model is pinned to text-embedding-3-small at 1536 dimensions — changing it invalidates the index, so it only changes via a documented re-embed procedure.
Where does my data live?
Postgres holds events, facts, objects, tasks, documents, and version history. Qdrant holds vectors in a shared collection with mandatory team_id payload filters on every query. RustFS (S3-compatible) holds original blobs and audio with versioning enabled day one. Every row, every vector, and every byte carries a team_id, enforced at the data layer rather than application logic.
How are answers cited?
A single raw event ("Met with John from Apple about licensing") produces multiple facts — Tim met John, the topic was licensing, the date was today — each linked back to the source event. When the agent answers a question, it surfaces inline citation chips that resolve to the raw voice memo, email, message, or document version, with the author, timestamp, and source attached. No black-box summaries.
How does privacy work inside a team?
Visibility lives on the event, not the team. Each event carries one of three modes: private (visible only to the author or source owner), team (visible to all team members), or specific_users (a named list). A brain dump captured in a team group chat can still be marked private. Team isolation is enforced at the query layer; per-event visibility is layered on top.
Can I export my team data?
Yes — full team data export is treated as a trust requirement, not a feature flag. Raw events are immutable and append-only, which makes export deterministic. The roadmap places portability ahead of growth-side features.
Is The Timeline end-to-end encrypted?
No. The agent processes content server-side, which is structurally incompatible with end-to-end encryption. Data is encrypted in transit and at rest. The privacy boundary is per-event visibility plus team scoping enforced at the data layer.
Try it on one real project.
Add Timeline to the conversations and calls where work already happens, then ask the first status question you normally answer by hand.
CAPTURED · CITED · TEAM-SCOPED
- 1Connect Slack, Telegram, meetings, or the project docs you already use.
- 2Let Timeline capture one week of decisions, blockers, files, and promises.
- 3Ask: "What changed, what is blocked, and what did we promise next?"
- 4Share the cited answer instead of writing a fresh status report.
- Every claim links back to the raw event, transcript, message, email, or document.
- Raw events are immutable; derived facts can be reprocessed without changing the source.
- Team isolation and per-event visibility are enforced below the UI.
- Custom MCP servers provide live reach while keeping captured tool results private by default.