Four capabilities. Everything that sits under them.

Ask in plain language. The agent reads the issues, docs, files and repositories in your workspace and answers against them, not against a generic model memory.

One prompt turns a release into subtasks with estimates and assignees, staged as an editable plan before anything is written to the graph.

Describe the project and the agent drafts its containers, work items and fields. You edit the draft before it is created.

Approved plans run as a sequence of real actions — create, assign, link, move, comment — against the same API a person uses.

The agent shows the exact set of actions it intends to take. High-impact plans do nothing until you approve them, and there are no destructive actions.

Every action executes under the caller’s own role. The agent cannot reach a project, team or file you cannot reach yourself.

What the agent did, when, on whose approval, and against which work item — recorded and reviewable after the fact.

500 AI messages a day on Pro and 3,000 on Scale, pooled across the whole team and reset at midnight UTC.

An opened pull request is reviewed against the work item it closes: scope drift, missing coverage, and files touched outside the plan.

A failed check comes back as a triaged summary attached to the work item instead of a wall of log output in another tab.

The agent reads the repository it is planning against, so decomposition references real modules and files rather than invented ones.

Drag work across columns you define. Status changes propagate to every other view and to any automation listening for them.

A dense, sortable table with filtering, grouping and bulk edits for the days you are triaging rather than browsing.

Due dates on a month or week grid. Drag an item to reschedule it and the change is written straight back to the work item.

What ships this quarter, and what is slipping. Work items laid out on one horizontal axis so a date problem is visible before it is a status-meeting problem.

Groom what is next, then pull it into a sprint. Priorities, estimates and ordering survive the move.

Break work down into child items that roll up to their parent, each with its own assignee, estimate and status.

Add the fields your team actually tracks, then save the filter combination you keep rebuilding.

Who is carrying what, across projects, before you assign the next thing.

Block-based docs with version history, living in the same container as the work items they describe.

Shapes, drawing and sticky notes for the shape-of-the-thing conversation. Changes are broadcast to everyone in the container.

Threaded discussion with attachments on work items and docs, so the decision stays next to what it decided.

Mail that arrives through the inbound parser is attached to the work item and stays there as a thread — no forwarding, no copy-paste.

Capture what was agreed and turn it into work items in the same place, rather than in a document nobody reopens.

One search over work items, documents, files and comments, with the source of each answer shown so you can open it.

The graph keeps the links between work, code and decisions. The longer a team uses it, the more the agent has to reason with.

Throughput, cycle time and workload distribution, drawn from the work graph rather than from a spreadsheet somebody maintains.

Import a ready-made project structure, or publish your own for the rest of the organisation to reuse.

A shared, pooled file space per team that scales with seat count. Files attach to work items and are served over signed, expiring URLs.

Private space tied to your seat, separate from the shared team pool. Other members cannot browse it.

Start and stop a timer on a work item, or enter time manually when you forgot to.

When something happens in the graph, evaluate conditions and run actions. Unlimited rules on both paid plans.

Cron schedules, field-change triggers and branching conditions, so an overnight triage or a Monday digest runs without anyone present.

Route incoming work by label, field or team, and set the assignee, priority and container automatically.

Decide what is worth interrupting someone for. Everything else arrives as a digest.

Connect a team to its own n8n instance and drive Lithora from workflows you already run.

Subscribe an endpoint to graph events. Deliveries are signed, retried on failure, and parked in a dead-letter queue if they keep failing.

The same REST API the product runs on, with scoped personal access tokens, so anything you can do in the interface you can script.

Repeated deliveries from an upstream system are recognised and dropped instead of creating duplicate work.

GitHub issues arrive as work items and stay in step. Close it in either place and both agree.

Reference a work item from a branch, commit or pull request and the link is made for you, with review state visible on the item.

Work moves to done as the pull request lands and the issue closes, instead of at the next standup.

Open a branch or a draft pull request straight from a work item, with the naming convention already applied.

Bring existing work in from GitHub, Linear or a CSV, with a preview of what will be created before anything is written.

Push updates into the channel your team already watches, and act on work from there — slash commands and message buttons that move a work item without leaving Slack.

Updates land in the channel or the DM. Both are outbound today: you read work there, you do not act on it there.

Deployment events report back into the work graph, so a shipped item is one that actually reached production.

Attach designs and documents to a work item as first-class links. Reference, not file sync — we do not claim otherwise.

Every integration reports connected, degraded or broken, with a reconnect path — so a silently expired token is visible, not mysterious.

The guest role is read-only and is not billable. Invite clients, executives, designers and contractors to the projects they need without buying them a seat.

Mint a read-only URL for a project. No login required, revocable at any time, with an optional expiry, and it exposes only project name, description and status plus task titles, status, priority and due dates.

Owner, admin, member and guest, enforced on the server for every request rather than only in the interface.

A new hire on a company domain can find their colleagues’ workspace and request access, instead of quietly starting an empty second one. Consumer email domains are excluded.

OIDC single sign-on with SCIM user provisioning, so joining and leaving is handled by your identity provider. Included on Scale.

Deleting a work item or project is a 30-day soft delete with a restore path, not a permanent cascade. Mistakes are recoverable.

Who changed what, and when, across the workspace — the same trail the agent writes to, for the people who work beside it.

AES-256 at rest and TLS 1.3 in transit, workspace data isolation, and field-level encryption for stored integration tokens.

Time-based one-time codes on top of password or SSO sign-in.

Take your work out as CSV whenever you want. Data portability is a feature, not a retention lever.

Expand the shared team pool from $10 per 100 GB per month. Tiers stack, on both Pro and Scale.