StellaryStellaryBeta
FeaturesHow It WorksPlansBlog
Overview
Concepts & architecture
Getting Started
Workspace, project, context, and tokens
API Reference
Backend routes, auth, and models
MCP Integration
MCP clients, agents, and workspace tools
FAQ
Sign inTry for free
FeaturesHow It WorksPlansBlog
Documentation
Overview
Concepts & architecture
Getting Started
Workspace, project, context, and tokens
API Reference
Backend routes, auth, and models
MCP Integration
MCP clients, agents, and workspace tools
?
FAQ
Sign inTry for free
StellaryStellary

The multi-agent command center for teams that ship.

Product

  • Features
  • How It Works
  • Plans
  • Blog
  • FAQ

Developers

  • Documentation
  • API Reference
  • MCP Integration
  • Getting Started

Company

  • About
  • Product ambitions
  • Editorial policy
  • How we compare tools
  • Legal Notice
  • Terms of Service
  • Privacy Policy
  • Cookie Policy
  • DPA

© 2026 Stellary. All rights reserved.

Legal NoticeTerms of ServicePrivacy PolicyCookie PolicyDPA
Features

What teams get with Stellary

Stellary is a delivery workspace where projects, cards, documents, cockpit steering, automations, and specialized AI agents all operate on the same system of record.

What teams come to Stellary for

Most teams are not looking for another AI surface. They want delivery, context, and execution to stop living in separate tools.

Run delivery in one workspace

Projects, scopes, boards, cards, comments, attachments, labels, and field-level structure stay in the same operating model instead of being split across planning and documentation tools.

  • Humans and agents reference the same delivery objects.
  • Less copy-paste between planning, execution, and status reporting.
Open guide

Keep context attached to the work itself

Specs, ADRs, briefs, notes, references, and templates can live at organization, workspace, project, or scope level, then link directly back to cards and missions.

  • Documents are part of execution, not a separate silo.
  • Better context quality for both humans and agent workflows.
Open guide

Operate with a workforce of specialized agents

Stellary is built around multiple agents with missions, proposals, approvals, and MCP access, not a single generic assistant tab bolted onto a board.

  • Agents can work from objectives or from card-linked missions.
  • Approvals and proposals stay visible instead of disappearing into chat logs.
Open guide

Steer execution above the board

Cockpit brings priorities, missions, decisions, proposed actions, and portfolio-style signals into one place so leads can steer without rebuilding context in meetings.

  • Useful when the board alone is too local for real steering.
  • Keeps execution signals tied back to actual work and decisions.
Open guide
Stellary/Checkout relaunch/Tasks
Docs scanned

Checkout relaunch

A project where humans and AI work inside the same system.

5 members
Labels
AI rules
To launch2

Checkout redesign

Context loaded. The mission can start.

Front
1/5 checklist
12
Product AI

Release checklist

Items to validate before shipping.

Docs
1/4 checklist
1
M
Marie
In progress1

Release summary

The docs update while the task keeps moving.

Docs
1/2 checklist
2
Docs AI
AI review1

Product note

The product lead only decides what matters.

Decision
1/1 checklist
1
N
Nina

Recent activity

0 handoffs
System•No action applied yet

The history fills up as soon as the AI starts changing the project.

AI mission

Product AI

Objective

Relaunch checkout

6 steps · final approval only

Execution log

01/06
Docs scanned6 steps

Global view

72%

Delivered

2

Blocked

3

Green light

Decisions

Validate the new payment flow
Review the release note

Todos

Re-read the checkout spec
Check the payment decision
C

A real board, not a mockup

How the system fits together

The product makes more sense as one loop than as a flat feature list. A team usually moves through these layers in roughly this order.

01

Set up the operating structure

Create or join an organization and workspace, invite the right people, and open the first project as the main delivery container.

Open guide
02

Turn intent into executable work

Use scopes, cards, labels, fields, comments, and attachments to map work in a format both people and agents can execute against.

Open guide
03

Attach context where it belongs

Link specs, ADRs, notes, and references directly to the relevant project or scope so context travels with the work.

Open guide
04

Run missions with the right approval model

Launch specialized agents on objectives or card-linked missions, review proposals, and keep sensitive actions under the right level of control.

Open guide
05

Scale with pilotage, automation, and integrations

Use cockpit, automations, MCP, and the REST API to steer work at workspace level and connect external systems without bypassing the model.

Open guide

Structure, onboarding, and governance

Before anything smart happens, Stellary needs a clean operating model: who is in the workspace, what they can access, and how a team gets a first project live.

Getting started

Create a workspace, launch a first project, add context, and prepare the ground for agents or integrations. This is the fastest way to understand the product in motion.

  • Best first read if you are new to Stellary.
Open guide

Team & access

See how organization, workspace, project, and pilotage roles fit together so people, agents, and reviewers do not all have the same reach by default.

  • Invitations, roles, and permissions explained in plain language.
  • Useful before inviting a broader team or opening pilotage workflows.
Open guide

Delivery and shared context

This is the spine of the product: projects structure the work, cards carry execution, and documents keep the shared context close enough for both humans and agents to act on it.

Projects, scopes, board, and cards

Projects are the primary delivery container. Inside them, scopes group work, the board exposes views and workflows, and cards hold status, ownership, discussion, and custom structure.

  • The place to understand what the team will touch every day.
  • Board structure stays aligned with how cockpit and agents reference work.
Open guide

Documents and knowledge

Documents can live at organization, workspace, project, or scope level. They are linked into execution so context travels with cards, missions, and decisions instead of living in a detached wiki.

  • Shared context for people and for agents that read or update linked docs.
  • Supported types map to actual work: specs, ADRs, notes, references, briefs, and templates.
Open guide

AI-assisted project framing

The wizard helps turn rough intent into a structured project draft with clearer scope, context, and next steps before the backlog hardens.

  • Useful when a team has intent but not yet an execution-ready project shape.
  • Outputs stay tied to the same project, scope, and document model as the rest of the app.
Open guide
Stellary/Checkout relaunch/Live run
Front AI · mission

Project board

The card travels Todo → In progress → Done with a full execution trail.

Todo
2

Relaunch payment flow

PSP + fallback, e2e on the critical path.

Checkout
Front AI4/7

Scope note

Parking lot items.

In progress
1

Release checklist

Train gates.

Done
0

Latest activity

Card moved to In progressChecklist fully readLinked doc section pinnedReview AI cleared edge casesPatch applied in workspaceComment added · card → Done

Execution log

Live

Linked documentation

Checkout · payment architecturev0.4 · linked

PSP primary route, card vault rules, fallback ladder when authorization is deferred.

Agent channel

Front AI

…

Review AI

…

Workspace patch

Watch agents execute on the board

Multi-agent execution and steering

This is where Stellary stops feeling like a standard project tracker. Agents, missions, cockpit, and approvals are built as operational flows on top of the same delivery model, not as side-panel chat.

Agents and missions

Workspace agents can run direct objectives or card-linked missions, submit proposals where needed, and work inside explicit tooling and approval boundaries.

  • Built for a workforce of specialized agents, not a single generic assistant.
  • Missions and proposals are first-class flows, not silent side effects.
Open guide

Cockpit and pilotage

Cockpit aggregates the signals that matter for steering: priorities, missions, decisions, proposed actions, and portfolio-style views across the workspace.

  • Useful when the board answers "what is happening here?" but not "what matters now?".
  • Decision logs and proposed actions stay tied back to delivery and governance.
Open guide

Automations

Automations trigger repeatable actions inside the same delivery and context model, for example when a project reaches a state or when a recurring workflow should run.

  • Automations stay scoped instead of bypassing workspace visibility rules.
  • A good extension point once the base delivery model is already clean.
Open guide
Stellary/Checkout relaunch/Cockpit

Review

In review

7 cards need a decision

Approve cockpit metrics export

Human review

Approve billing model draft

Human review

Release briefing content check

Human review

Log retention policy review

Human review

Validate produced diff

Front AI · branch checkout-guard

Human review

Plan the next sprint

Product AI · scope doc

Human review

The cockpit surfaces only what matters

MCP, API, and external workflows

External AI clients and service integrations should plug into the same workspace model as the UI, not tunnel around it. This is where MCP and the REST API matter most.

Built-in MCP server

Connect Cursor, Claude Code, or another MCP client to the same workspace data and tools used by the product, with the same identity and mission model.

  • Best place to understand tokens, approvals, queued missions, and client setup.
  • Useful when external AI needs real workspace context instead of flat prompts.
Open guide

REST API

The API reference lists the real routes behind auth, workspaces, delivery, documents, agents, pilotage, billing, and MCP-related flows. It is the contract for custom integrations.

  • Route-level alignment with backend behavior rather than aspirational endpoints.
  • Useful when you want to understand or extend what the UI is already doing.
Open guide

Choose the right entry point

Different people should start in different places. These paths are usually more useful than reading every page in order.

Start with the product ambitions

Read this first if you want an honest view of what Stellary is optimizing for, what it is not trying to be, and whether the product is even a fit.

Open guide

See the documentation map

Open the docs hub if you already know you need Stellary detail, but you are not yet sure which guide matches your job to be done.

Open guide

Understand the delivery model

Start here if your first question is how projects, scopes, cards, fields, comments, and views work day to day in the product.

Open guide

Understand documents as context

Read this if your main problem is fragmented context and you want to see how specs, notes, ADRs, and references stay attached to work.

Open guide

Run agents and missions

Read this before turning Stellary into a serious multi-agent system. It covers agent setup, missions, proposals, memory, and approval behavior.

Open guide

Connect an MCP client

Use this if you want Cursor, Claude Code, or another MCP client to operate on the same workspace model as the product.

Open guide

Build an API integration

Go here when you need the route-level contract behind auth, workspaces, delivery, documents, agents, cockpit, billing, and MCP-related behavior.

Open guide

See it in action

Everything on this page works together in a single workspace. Start a project and see how agents, docs, and delivery connect.

Free during early access — no credit card required.

Start a projectWatch the demo