Understand the fundamental building blocks of Moonage — Spaces, Smart Actions, the context graph, and more.

Overview

Moonage is built around a few key abstractions that work together to create intelligent, context-aware workflows. Understanding these concepts will help you get the most out of the platform.

Spaces

A Space is a persistent agent environment. Think of it as a specialized team member that understands your tools and processes.

What's inside a Space

Component	Description
Context graph	Structured knowledge from your connected tools
Integrations	OAuth connections to external services
Persona	The agent's personality, instructions, and capabilities
Memory	Conversation history and learned preferences
Smart Actions	Automated workflows the agent can execute
Schedules	Recurring automations with cron-based triggers

Space isolation

Each Space is fully isolated:

Data: Context graphs are separate — one Space can't access another's data
Auth: OAuth tokens are scoped per Space
Memory: Conversation history doesn't leak between Spaces
Config: Personas, schedules, and Smart Actions are Space-specific

This means you can have a Product Space connected to Notion and Slack, and an Engineering Space connected to GitHub and Linear, each with different personas and workflows.

Space lifecycle

Created → Active → (Paused) → Archived → Deleted

Active: Fully operational, processing queries and running schedules
Paused: Schedules suspended, but still queryable
Archived: Read-only, no execution, retains data for 90 days
Deleted: Permanent removal after 30-day grace period

Smart Actions

Smart Actions are multi-step workflows that execute across integrations. They're the core automation primitive in Moonage.

Trigger types

Type	Description	Example
Conversational	Ask the agent to do something	"Summarize open issues"
Scheduled	Run on a recurring basis	Every Monday at 9am
Event-driven	Triggered by webhooks	On new GitHub PR
API	Triggered programmatically	POST /spaces/:id/actions

Execution model

Smart Actions use a DAG (Directed Acyclic Graph) execution model. The LLM planner analyzes the request and produces a dependency graph of tool calls:

Wave 1: [Fetch issues] + [Fetch channels]    ← parallel
Wave 2: [Summarize results]                   ← depends on wave 1
Wave 3: [Post to Slack] + [Update Notion]     ← parallel

Key properties:

Independent steps execute in parallel waves
The planner re-plans after each wave based on intermediate results
Failed steps are retried with exponential backoff
Circuit breakers prevent cascading failures

Action anatomy

Each Smart Action consists of:

Intent — what the user wants to accomplish
Plan — the DAG of tool calls the LLM produces
Execution — parallel wave-based execution with progress events
Result — structured payload with raw MCP data from each tool

Context Graph

The context graph is how Moonage understands your data. It's a structured representation of entities and relationships across your connected tools.

How it works

When you connect an integration, Moonage:

Indexes — fetches and stores entity data (pages, issues, messages, etc.)
Extracts — identifies entities, relationships, and metadata
Embeds — generates vector embeddings for semantic search
Links — connects related entities across integrations

Entity types

Type	Sources	Examples
Document	Notion, Google Drive	Pages, docs, spreadsheets
Issue	Linear, GitHub	Bugs, features, tasks
Message	Slack	Channel messages, threads
Code	GitHub	Files, PRs, commits
Person	All	Team members across tools

Cross-tool relationships

The real power of the context graph is cross-tool linking. When someone mentions a Linear issue in Slack, or links a Notion doc in a GitHub PR, Moonage captures that relationship.

This allows queries like:

"What Notion docs are related to this Linear project?"
"Who has been discussing this GitHub PR in Slack?"
"Show me all context around the authentication refactor"

Freshness and sync

Real-time: Slack messages, GitHub webhooks (when configured)
Near real-time: Polling every 5 minutes for most integrations
Manual: Trigger a full re-sync from Space Settings
Stale data: Entities not updated in 30 days are flagged

Personas

A persona defines how your agent communicates and what it can do.

Configuration options

Option	Description	Example
Name	Display name	"Eng Bot"
Instructions	System-level directives	"Always include code examples"
Tone	Communication style	Formal, casual, technical
Tool access	Which integrations are available	GitHub + Linear only
Model	LLM preference	Sonnet, Haiku, Opus

Built-in personas

General Assistant — balanced for most tasks, all tools enabled
Engineering Lead — technical tone, prioritizes code and issues
Product Manager — structured output, focuses on specs and feedback
Data Analyst — code execution enabled, optimized for data tasks

Custom personas

Create custom personas with specific instructions:

Name: Release Manager
Model: Sonnet
Tone: Professional, concise

Instructions:
- Focus on release readiness and blockers
- Always check Linear for open issues before reporting
- Format output as numbered checklists
- Escalate critical bugs by mentioning the assignee

Memory

Moonage agents have persistent memory within a Space. This includes:

Short-term memory

Current conversation context (messages in the active session)
In-flight Smart Action state and intermediate results
Recently accessed entities from the context graph

Long-term memory

Conversation history (configurable retention: 7, 30, or 90 days)
Learned preferences (e.g., preferred Slack channels, output formats)
Frequently accessed entities and common query patterns

Memory and privacy

Memory is scoped to the Space — it never leaks across Spaces
You can clear memory at any time from Space Settings
Archived Spaces retain memory in read-only mode for 90 days
Deleted Spaces permanently remove all memory after the grace period

Core Concepts