Agent orchestration for Glue. Agents observe your systems, create plans, execute workflows step by step, and produce artifacts — with human approval at every stage.
Agents are config, not code. One execution engine runs every workflow.
Every action in Glue follows one pipeline. An event triggers an agent, which creates an observation, which becomes a plan the user can approve. The system executes the plan step by step, producing artifacts at each stage.
Observer agents watch your systems 24/7 — GSC rankings, Sentry errors, PostHog usage, Jira tickets, competitor websites, codebase changes. When something happens, they create an observation.
The system matches each observation to a playbook — a predefined workflow that knows how to resolve it. It creates a plan: "here's what happened, here's what I recommend, here are the steps." The user never sees raw data.
When the user approves, executor agents run each step — calling APIs, searching code, generating content, creating tickets. Each step produces an artifact the user can review, edit, or reject.
The user never sees an observation. They see a plan — the system already analyzed the situation and is presenting a recommended course of action with clear steps. The morning brief summarizes what agents found and did overnight.
Stella has 7 first-class entities. Each maps to a database table prefixed with stella_. Together they represent the complete lifecycle from signal to output.
Follow a real event through the entire pipeline — from webhook to destination.
TypeError: Cannot read properties of undefined (reading 'map') — 47 events in 1 hour. Error Tracker agent receives the webhook.
stella_observations: source='sentry', title='TypeError spike — 47 events/hr', raw_data contains full stack trace, affected file, error count.
System matches to playbook 'Investigate Error' (#15). Creates stella_plans with severity='critical'. Step 0 (Detect) is pre-completed with the observation data as its artifact.
Morning brief: 'TypeError spike in dashboard — 47 events. Agent has analyzed the error and traced it to DashboardPage.tsx:142.' Plan appears in the insight queue with [Investigate] button.
Agent reads the stack trace, searches codebase for the function, checks git blame for recent changes. Produces analysis: 'Null check missing on repos.map() — happens when project has no repositories.'
Agent walks the call graph: DashboardLayout → DashboardPage → RepoList.map(). Identifies the exact line and suggests fix: add optional chaining repos?.map().
Agent generates a specification: add null guard at line 142, add empty state component, estimated 30 minutes.
Agent creates GLUE-451 in Jira. Priority: P1. Assigned: Sarah K. Sprint: 15 (current). Links to Sentry issue.
Observer agents watch your systems and surface signals. Executor agents do the work — writing, analyzing, creating. Some agents do both.
Watches: Google Search Console rankings, CTR, indexing
Creates: Ranking drops, CTR anomalies, indexing issues
Watches: Sentry / PostHog error events
Creates: Error spikes, new exceptions, regressions
Watches: PostHog analytics
Creates: Feature usage drops, funnel degradation
Watches: Competitor websites (scheduled crawl)
Creates: New features, content updates, pricing changes
Watches: Jira / Linear / ClickUp webhooks
Creates: New tickets, overdue tasks, blocked items
Watches: npm audit, Dependabot, GitHub alerts
Creates: CVEs, vulnerable packages
Creates: Blog posts, articles, meta tags
Creates: Error traces, root cause analysis, fix specs
Creates: PRDs, technical specifications
Creates: Implementation plans, file-by-file breakdowns
Watches: New tickets (via Ticket Monitor)
Creates: Classifications, priority assessments, sprint suggestions
Creates: Meta tag rewrites, schema markup, SERP previews
Tools are what agents use to interact with systems. Each playbook step declares which tools it needs — the execution engine provides only those. This is the permission boundary.
The execution engine creates an MCP server with ONLY the declared tools. The LLM cannot call tools outside this set.
Each playbook defines a workflow — ordered steps, tools per step, artifact types, and approval chain. Users can also create custom playbooks.
Every agent is a row in the database. The execution engine reads the config and runs it. To add a new agent, insert rows — no TypeScript required.
// ticket-triage-agent-sdk.ts
// 400+ lines of custom code PER agent
function buildTriagePrompt(ticket) {
return `# TICKET ANALYSIS
## Phase 1: Triage (MANDATORY)
Use ticket-triage skill...
## Phase 2: Specification
Use spec-generation skill...
`;
}
// Every agent = a new TypeScript file
// Every prompt change = code deploy
// No user customization possible-- stella_playbooks
INSERT INTO stella_playbooks
(name, page_key, model)
VALUES
('Triage New Ticket', 'roadmaps', 'haiku-4-5');
-- stella_playbook_steps
INSERT INTO stella_playbook_steps
(playbook_id, step_index, name,
agent_prompt, tools, artifact_type)
VALUES
(26, 0, 'Classify',
'Classify ticket {observation.title}...',
'{codebase_search,ticket_search}',
'classification');
-- One engine runs ALL playbooks
-- Prompt changes = DB update (no deploy)
-- Users create custom playbooks in UIThe execution engine runs in Java. The UI runs in Next.js. One request flow connects them.
TypeScript / React / App Router
Spring Boot / PostgreSQL / MCP
| Capability | Java Stella | Claude Agent SDK |
|---|---|---|
| Agentic loop | AgentExecutor | Built-in |
| Tool persistence | Logs every call | Not built-in |
| Cost tracking | Per-iteration tracking | Not built-in |
| Multi-agent routing | SessionOrchestrator | Single-agent |
| Integration clients | 5 built (Jira, Linear, ClickUp, Sentry, GitHub) | Must build |
The Agent SDK is great for single-agent tasks. Java Stella is the orchestration layer that coordinates multiple agents, persists every tool call, tracks costs, and routes requests across sessions.
The current agent codebase maps directly to Stella entities. The intelligence stays — the orchestration changes.
Users build their own playbooks on the Agents page. Same tables, same engine, same artifact renderers. Define a trigger, choose tools, set approval chains.
Answers for engineers, PMs, and anyone working with Stella.
stella_agents observe. stella_observations record signals. stella_playbooks define resolutions. stella_plans present them to users. stella_steps execute. stella_artifacts produce output. Users approve. Destinations receive.