One operating system for delivery
Cards, documents, cockpit, pipelines, plugins, and MCP should reinforce the same source of truth instead of fragmenting work across tools.
Stellary aims to be the system where project context, human decisions, and AI execution stay aligned—from cockpit signals to governed runtime, documentation, and agents. This page describes product ambitions; it is directional and not a delivery commitment.
Updated April 12, 2026
Cards, documents, cockpit, pipelines, plugins, and MCP should reinforce the same source of truth instead of fragmenting work across tools.
AI should recommend, explain, and accelerate—but risky actions stay explicit, permissioned, and traceable.
Runs, reviews, and docs should distill into reusable playbooks, patterns, and decisions—not just accumulate text.
We are building toward a closed loop: structured context → governed execution → human review → updated knowledge. Agents and automation should plug into that loop without replacing accountability.
The product should feel like a command center for teams that ship software: clear status, explicit trade-offs, and AI that works on real project state—not generic chat disconnected from work.
As agent usage grows, assignment should move from purely manual to assistive: suggesting the right agent for a mission based on skills, load, cost, and history—without opaque autopilot.
Memory should evolve from raw logs into durable team intelligence: distilling missions, documents, and reviews into patterns, checklists, and playbooks people can actually reuse.
A contextual assistant across the product should help on any surface without breaking local context—useful, grounded, and tied to permissions and real actions.
Teams will mix local runtimes, MCP, and cloud execution. Stellary should route execution intelligently with clear governance, explainable behavior, and safe defaults.
MCP servers should propagate to agents as filterable, assignable tools with visible provenance—powerful, but governed so tool sprawl does not become a security or UX problem.
We are actively investing in governed cloud execution for agents (persistent environments, reviewable output, preview-first workflows) as a foundation for this trajectory.
Critical trade-offs should become first-class decision objects with owners, options, and history—tied to cockpit and delivery reality, not buried in comments.
Documentation should graduate into a premium collaborative space: sharing, editorial responsibility, and—where it makes sense—real-time co-editing across humans and agents.
Knowledge should be “alive”: linked to cards, missions, and reviews, with signals when guidance drifts out of date.
Early thinking and ideation should have a home inside the project: capture rough notes, refine with structured AI assistance, and convert outcomes into specs, cards, or decisions when ready.
External collaboration should be bounded: guests with scoped access, optional public read-only views where appropriate, and visual review tools that make feedback precise.
Where design and implementation meet, deeper integrations (for example design tools) should connect handoff, previews, and validation without forcing teams to live in silos.
A local presence—desktop shell and a controlled bridge to repositories and machine-local tools—can unlock hybrid workflows that pure web apps struggle to reach, with security treated as a first-class constraint.
Ambitions are ranked, explored, and sometimes postponed inside our internal product backlog. Items move between discovery, planning, and implementation as we learn.
For what Stellary does today, rely on the in-product experience and the documentation. This page explains direction—not a fixed roadmap or timeline.