Activity, Calendar & Inbox

Activity, Calendar & Inbox

Three surfaces keep everyone, human and agent, in sync on what is happening. The Activity feed is the org's running history: an append-only record of every meaningful change. The Inbox is your personal triage queue, scoped to you alone, where assignments, mentions, and closed loops land to be cleared fast. The Calendar holds team and personal events, with an honest, source-linked pre-meeting brief drawn from your own data. All three update live, so the feed, your boards, and the bell stay current on their own without a reload.

Activity feed

The Activity feed is the org's running history, an append-only log of every meaningful change. Whenever someone creates or edits a note, moves a task, runs a meeting summary, comments, adds a member, schedules an event, or records a decision, an immutable activity event is written. Each event records who did it (the actor), what kind of thing changed (the entity type and id), the kind of change (the event type), the project it belongs to when relevant, and a small payload such as a title or snippet. Events are never edited or deleted, so the feed is a trustworthy audit trail. You reach it from Activity in the sidebar.

What the feed records

The feed threads the whole org into one timeline. The kinds of moments it captures include:

• Pages created and updated across tasks, projects, notes, and meetings.
• Lifecycle changes like task status transitions and assignments.
• Comments posted on the things people are working on.
• Decisions, blockers, approvals, and action items surfaced from meetings and work.
• Membership changes when someone is added to the org or a project.
• Calendar events as they are created, updated, and deleted.

Reading the feed

The org feed shows the newest events first. The web view groups them by day, with friendly headers (Today, Yesterday, weekday names within the last week, then dated headers further back) and a count per day, so you can scan a day at a glance. Times are relative ("5m", "2h") with the exact timestamp on hover. High-signal moments such as decisions, blockers, approvals, comments, new notes, and new members render as richer cards with a headline and an excerpt, while routine churn stays compact, and a run of similar low-signal changes collapses into a single expandable line so the feed reads as signal, not noise.

Per-entity history

Beyond the org-wide feed, every item carries its own history. The feed can be scoped to a single entity, for example one task, note, project, or meeting, and returns just that item's events, newest first. This is what powers the Activity tab you see on a task and the timeline on other items: open anything and the surrounding history is already there, an audit trail of how it reached its current state.

Jumping to the source

Activity rows link straight back to the item they describe. Rows for projects, notes, and meetings resolve to a real in-app link, so clicking the row (or the "Open" link on a richer card) jumps you to the source. The activity feed is also where notes get composed: you can drag an activity row straight into a note's editor and it lands as a clickable citation. That drag-and-drop flow is covered in full on the Notes page.

Live updates

The feed is genuinely live. Elliptic holds an open server-sent events stream to the org's activity stream, and the instant any activity is recorded anywhere in the org, the relevant views refresh on their own, with no reload and no polling. Because the stream also knows what kind of thing changed, it refreshes the matching area too: a new note nudges your notes list, a task change nudges your boards, and so on. You can leave the Activity page open as a true ambient view of the org.

How the stream works

When an activity event is written to the database, Postgres fires a NOTIFY on a dedicated channel. A listener bridges that into an in-process broker, which fans the event out to every connected client subscribed to that organization over its stream. Each client gets its own bounded queue, and if a client falls behind, the oldest events are dropped rather than blocking everyone else, so a slow tab never stalls the live feed for the rest of the org.

Inbox and notifications

The Inbox is your personal triage queue. It is recipient-scoped, meaning only your own notifications appear, never anyone else's. It collects the things that actually need your attention and is built to be cleared fast, from the keyboard. You reach it from Inbox in the sidebar, and the All / Unread / Archived tabs across the top control what you see.

What lands in your Inbox

Notifications are typed, and the type tells you why you got it:

You are never notified about your own actions, the system skips self-notification entirely. Each notification shows who triggered it (the actor's name, when one is recorded), a title, an optional snippet, and a relative time. "Meeting action done" notifications highlight that something finished and point back to the meeting they came from.

Unread, all, and archived

A notification counts as unread until you read it, as long as it has not been archived and is not currently snoozed. The header shows your live unread count, and the bell mirrors it. The three tabs filter the queue:

• Unread shows only items you have not yet read, that are not archived, and that are not currently snoozed away.
• All shows your full notification history, read and unread together.
• Archived shows the items you have cleared out of the active queue but kept for reference.

Triage actions

Each notification can be acted on individually, and the whole queue can be cleared at once:

• Mark read drops a single item out of your unread count. Opening a notification's source marks it read too.
• Archive removes it from your active queue but keeps it under the Archived tab.
• Snooze hides it for a while and brings it back when the snooze passes. The snooze time must be in the future, and the keyboard shortcut snoozes for an hour.
• Mark all read clears every unread notification in one action.

Triage from the keyboard

The Inbox is designed to be worked through without the mouse. Move the focus with j and k, then act on the focused item:

Opening an item jumps you to the underlying thing: the project, meeting, note, or the task in its board. Unread items carry a small accent dot and bolder text so they are easy to spot as you move down the list.

The notification bell

You do not have to be on the Inbox page to triage. The bell in the top bar shows your unread count (as a number, or "9+" when there are more than nine) and opens a compact version of the Inbox in a popover. The same keyboard shortcuts work there too, so you can clear a few items and get straight back to what you were doing.

Catch up

When unread has piled up, the Catch up panel at the top of the Inbox rolls everything into something you can clear in a few moves. Instead of a flat list, it groups your unread notifications by the entity they are about, so a task with five updates shows as one line, not five. Each group shows the entity's title, how many unread notifications it has, and the panel tells you your total unread and a breakdown by type.

Mark a whole entity read

Each catch-up group can be cleared in one action. Marking a group seen marks every unread notification for that entity as read at once, so you can acknowledge an entire thread of churn (all the updates on one task, one project, one note) without opening each notification. The panel tells you how many it marked.

AI: what changed since your last visit

For a project, Elliptic can write a short what changed digest from the project's recent activity. It reads the project's most recent activity events, groups related changes, and returns a few concise bullets summarizing what moved while you were away. When nothing has changed recently, it says exactly that rather than inventing activity. Like every AI feature in Elliptic, this summary runs on your organization's own model key, so the cost lands on your provider bill and your data stays under your control.

Delivery preferences

The in-app Inbox is always on, it is the canonical place your notifications live and cannot be turned off. What you can tune is the extra delivery on top of it: email for specific triggers, and push to your registered devices.

Email notification preferences

Email is governed by five per-trigger toggles, each of which you can set at two levels: a workspace default that applies across the org, and a per-project override that wins for one project when set. Every toggle defaults to on, so you receive email until you opt out. The triggers are:

When a trigger fires, Elliptic resolves your preference by checking the project override first; if you have set one for that project, it wins, otherwise the workspace default applies, and if you have set neither, email defaults to on. This lets you, say, keep email on everywhere but mute a noisy project, or stay quiet by default and turn email back on for one critical project. None of this affects the in-app Inbox, which always receives the notification.

Push notifications and devices

Elliptic can also send push notifications to your registered devices alongside the in-app Inbox. A device registers its push token (Expo push tokens are the default transport), tagged with its platform (iOS, Android, or web), and the registration is kept fresh as the device checks in. When a notification is created for you, Elliptic fans a push out to your registered devices on a best-effort basis: it runs alongside the in-app notification and never blocks it, and a failed push is logged and shrugged off rather than holding anything up. You can revoke a device's token to stop push to it. Push delivery is gated by a server setting, so it is active only when your deployment has it enabled.

Calendar and events

The Calendar puts team and personal events in one month grid so nothing slips through the week. You reach it from the sidebar. Move between months with the arrows, jump back with Today, and filter the view with the All / Team / Personal tabs.

Team events vs. personal events

Every event is either a shared team event or a private personal event, and that scope decides who sees it and who can change it.

Both kinds show in your calendar together, so your week is complete in one view. Other people's personal events are never visible to you, the Calendar simply does not return them, and asking for one directly comes back as not found.

Event fields

An event carries a small, predictable set of fields:

• Title is required.
• Description and location are optional (a room, or a link).
• Start and end are timestamps; the end must not be before the start.
• All day flips the event off the clock so it spans the day without times.
• Visibility is Team or Personal, which sets the scope above.
• Linked meeting optionally ties the event to a meeting in the org.

Create and edit an event

1. 1
   Start a new event

   Click New event in the header, or click the date number on any day cell to seed that date. A dialog opens.
2. 2
   Fill in the details

   Give it a title (required). Choose Team or Personal visibility. Pick a date. Set start and end times, or flip the All day switch to skip times. Optionally add a location and a description.
3. 3
   Save

   Create event adds it to the grid immediately. The end must not be before the start before it lets you save.
4. 4
   Edit or delete later

   Click any event chip to reopen the dialog with its details filled in. Change anything and Save changes, or Delete to remove it. Editing a team event is limited to its creator or an admin; editing a personal event is limited to you, the owner.

Creating, updating, and deleting an event are all recorded in the activity feed, so calendar changes show up in the org's history like everything else.

Linking an event to a meeting

An event can point at a meeting in your org. The meeting has to belong to the organization, otherwise the link is refused. Once linked, the event chip shows a small document icon, and its popover offers an "Open meeting" link straight to the transcript and summary. The link also feeds the pre-meeting brief below: action items from that meeting's latest summary become part of the brief.

Reading the grid

• Today is highlighted; weekends and days outside the current month are tinted so the month frame reads clearly.
• Event chips show the start time and title, color-coded by team or personal. Hover or focus a chip for a quick popover with the full time range, the team-or-personal scope, and the location.
• Busy days cap at three visible chips; a "+N" opener reveals the rest for that day.
• Linked meetings show a document icon and an "Open meeting" link in the popover.

Pre-meeting brief

Open an event and Elliptic can generate a short pre-meeting brief, a handful of bullets of real context pulled from your own Elliptic data, each with a clickable source. It is deliberately honest: it only surfaces facts it can actually point to, and if there is nothing relevant, it returns an empty brief with zero confidence rather than inventing filler.

The brief draws from three sources, in order:

• Open tasks assigned to the event's owner, a few of the most recently updated, still-open ones, each labeled with its KEY-number identifier.
• Follow-ups from a linked meeting, the action items from the linked meeting's latest summary, when the event is tied to a meeting.
• A related note, the note whose text most overlaps with the event's title and description.

Each bullet links to its source, so you can click straight through to the task, meeting, or note. The brief is capped at a few bullets and carries a confidence score that rises with how much real context it found, so a brief built from several genuine sources reads as more confident than one with a single thin match. When there is genuinely no prior context, the brief comes back empty with zero confidence instead of padding.

Agent-native: the same surfaces over MCP

Agents are first-class members in Elliptic, and they operate these surfaces the same way you do, through the company-brain MCP, on your org's own key. An agent can follow what is happening, keep the calendar tidy, and prepare for meetings without a human relaying it. The relevant tools mirror the app:

Because agents act through the same recipient scoping, role checks, and activity recording as people, anything an agent does shows up in the feed with the agent named as the actor, and its calendar changes and event briefs behave exactly like yours. See the Company-brain MCP page for how to connect an agent and what each tool accepts.