Updates

The Updates feed is your project's living timeline — what's happening across everything connected to the project, curated automatically so you can catch up at a glance.

How the feed works

Every row in the feed is a topic: one real piece of work, followed from start to finish. That can be a deal, a feature, an incident, an order, a hire, a meeting being arranged, or one of your own tasks. Each topic is named for what it's about ("Sales: Acme — Enterprise, Q3", "Incident: checkout — error spike") and gathers everything about that work in one place, from every app you use. The same deal discussed over email, in chat, and in your CRM stays one topic.

As new activity arrives, the topic gains a new beat: a one-line headline of what just happened, with detail underneath. The newest beat is the topic's current status. Click a row to open the topic's page: anything waiting on you at the top, then its whole history, newest first; back returns you to the feed where you were. Timestamps show when things actually happened (when the email arrived, when the message was sent), not when Avi processed them.

Your tasks are topics. When something happens that is the work of one of your open tasks, such as the vendor's quote for "Get the office quote" or the signed contract for "Send Hooli the contract", it lands on the task itself, titled by the task's name, instead of on a new topic beside it. A task never shows up on its own. It appears the first time real work about it arrives. After that, completing or reopening the task shows on the same topic, and renaming the task renames the topic. If a topic about that work already exists, it is folded into the task: its whole history moves under the task's name, and later activity lands on the task. Open the task from the topic with Open task.
Many events, few rows. A busy topic is still one row: it moves to the top when something worth a look happens, and routine progress is added to its timeline quietly without moving it. Recurring notices, like marketplace renewals, payouts, or sign-ups, are kept together as one topic per month with a running tally, not a row for each one. When a few messages about the same moment arrive together, they're written as one beat.
Routine record activity is one row a month. Records moving through your tools in the ordinary course of business — deals appearing and changing stage in your CRM, for example — are kept on one topic per month ("Sales: Pipeline deals — October") with a running count, however many records there are. A record gets a topic of its own when there is a reason for you to follow it: it is yours (the deal's owner is you), people are already emailing, messaging, or working a task about it (its changes then land on that conversation), or it turns — a deal won or lost always gets its own topic, worth everyone seeing. Older per-record topics that held nothing but routine activity are folded into the month's row.
The unread dot is personal: it tracks what you have and haven't seen. A topic you've read comes back as unread only when something worth a look happens.
The small icon on a row shows where its latest activity came from (email, Slack, and so on); a task's row shows a checkmark.
A topic that has gone quiet comes right back to the top when its work picks up again.
In the Avi mobile app, tabs at the top sort your automations by what they're doing, under a one-line summary ("1 needs you, 2 working"). All is the feed. Needs you lists automations waiting on your answer — the number beside it is how many. Active lists every live automation: the ones working right now first (the number beside it counts those), then the ones waiting for their schedule or trigger, then any paused for the day. Finished lists what your automations concluded, succeeded and failed, newest first. Open an automation from any of these tabs to answer it or read its full outcome. Automations you stopped or archived live in the Automations panel. You can say the tab names in a voice session.
The feed stays current on its own as activity arrives. In the mobile app, you can also pull the feed down from the top to refresh it on demand.

Automatic curation

Avi curates the feed for every project by default — no setup. As activity arrives from your connected sources, Avi decides what's worth keeping, places it on the topic it belongs to (or on one of your tasks, or starts a new topic when it's genuinely new work), and writes the timeline beats. Replies in the same thread stay together on one update, so a conversation is understood in context rather than message-by-message. Avi keeps the substance from everyone in your conversations — decisions, agreements, action items, key facts, open questions — whoever said them, you included, so you and Avi share the full picture of what your team is doing. It filters the noise — newsletters, bulk mail, and content-free chatter like reactions, acknowledgements, and off-topic banter — no matter who sends it. A message that @mentions you is always given full consideration — and so are your own messages: Avi reads each one alongside the conversation it's replying to, so a quick "approved", "ship it", or "yes, go ahead" from you lands as the decision it is, not dismissed as a throwaway.

Curation never creates or changes tasks. Tasks are yours. Avi only records what happened, on the task it was about.

The Curator

Every project has a Curator: the automation that keeps this feed. You'll find it in the project's Automations list. It's always on — it can't be stopped, archived or deleted, and it needs no setup.

It waits two minutes, then reads everything together. When new activity arrives, the Curator starts two minutes later, so a burst of replies in one thread is curated as one development, not one message at a time.
Some things are filed straight away. An app asking for your approval, and changes to your own tasks, land on the feed without waiting for the Curator.
It notifies you only when something deserves it. A development the Curator marks as worth your attention notifies you. One it files quietly, such as a routine reply joined to a topic you already have, doesn't, and its own sessions never notify you.
It looks things up before it decides. When a message can't be understood on its own — a quick "lgtm" to something it can't see — the Curator reads the thread, task, deal, event, pull request, ticket or file it refers to first.
Tell it what matters. Its Instructions tab has two views, picked from the menu at the top: Built-in (Avi's curation rules, kept up to date; you can read them but not change them) and Custom. Write what matters in this project's feed, in your words — yours are added to the built-in ones, and where the two disagree, yours win. You can also ask Avi in chat ("tell the Curator customer escalations always matter").

A few things skip the editor entirely because you must never miss them: an automation concluding its work, hitting its daily budget, or asking you a question always posts directly. These items are titled by the automation ("Collecting shirt sizes from the team"). When an automation is, or was, working a topic, the row shows it on its own line under the latest activity: the automation's name and its state — a live state (working, needs you, paused) as a badge, a finished one as plain text with when it ran — so a completed automation never reads as the outcome of later activity on that topic. A question shows as a Needs you item — open it and answer right in the feed (tap a choice or type a reply), and the automation resumes with your answer. Each question carries a deadline and the automation's stated fallback, and its row keeps the whole story: asked, then answered — or expired into the fallback.

Some apps also publish their own digest updates straight into the feed. Those belong to the app that writes them: curation never merges, regroups, or rewrites a digest.

Grouping is automatic

Keeping related activity together is Avi's job, not yours. The Curator places each development on the topic it belongs to — on one of your tasks first, when it's that task's work — and opens a new topic only for genuinely new work. Two of your tasks are never merged, and a topic that turns out to be one of your tasks' work is folded into the task.

Beats know their records

Opening an update shows its whole story, newest beat first, every beat in full — nothing to expand. Every beat Avi writes remembers exactly which records it came from — the email thread, the deal, the file, the ticket — and the app's own link to each. Each beat carries those links to jump straight into the source app, and when you ask Avi to act on something in the feed ("reply to that thread", "open that file"), it goes directly to the record instead of searching for it first.

Ask Avi about your feed

When you chat with Avi in a project, it already has your most recent updates in view — so you can ask "what happened today?" or "anything I missed on the Acme deal?" and get a straight answer without telling it to go look. For anything older or more specific, it pulls the full feed or opens a single update to read the whole timeline.