Why Open Astra

Most agent frameworks are wrappers — thin layers over a single LLM call that add routing and a tool list. Open Astra is a runtime: a production-grade backend with persistent memory, hierarchical orchestration, and multi-tenant auth that your agents run inside.

Who it is for

Open Astra is designed for engineers and teams who need to:

• Run autonomous agents that remember context across sessions, days, and projects
• Orchestrate multi-agent pipelines where a root agent decomposes work and delegates to specialists
• Expose agent capabilities via a REST and WebSocket API to other services or frontends
• Control costs and behavior with per-agent quotas, approval workflows, and provider routing
• Deploy reliably in production with self-healing, diagnostics, and structured events

It is not the right tool if you need a visual, no-code workflow builder, a single-user desktop app, or a managed cloud agent service with no infrastructure to manage.

Five key differences

1. Memory that persists and compounds

Most frameworks have no memory or rely on a single vector store with naive retrieval. Open Astra has a 5-tier memory architecture that mirrors how humans store information:

• Tier 1 — Session messages: raw conversation history in PostgreSQL, fast to access, bounded by session
• Tier 2 — Daily notes: categorized observations (decisions, outcomes, strategies) that persist beyond sessions
• Tier 3 — User profile: structured facts about each user, updated incrementally
• Tier 4 — Knowledge graph: entities, typed relationships, multi-hop traversal, temporal decay
• Tier 5 — Procedural memory: learned workflows with fast-path trigger matching

Search uses RRF (Reciprocal Rank Fusion) across Typesense BM25+vector and pgvector cosine similarity simultaneously, so retrieval is both precise and semantically aware.

2. Context assembly is deterministic and auditable

In Open Astra, the context sent to the model is built by context/assembler.ts in a fixed, predictable order: SOUL.md ethics prefix → workspace files → system prompt → memory context → conversation history. Each layer has a defined token budget. You can inspect exactly what was sent to any model call via the event log.

Workspace files — dropped into a ./workspace/ directory — are hot-reloaded via fs.watch with SHA-256 deduplication, so context changes take effect within 500ms without a restart.

3. Hierarchical swarms with permission sandboxing

Open Astra supports true multi-agent orchestration: a root agent can spawn sub-agents to work in parallel, sharing state via a shared blackboard. Sub-agent tool permissions are the intersection of the parent's allow list and the sub-agent's allow list — spawning can never escalate privilege. Conflicts between sub-agents are resolved by a debate protocol before the root agent synthesizes results.

# Parent agent config
spawn:
  enabled: true
  allowedTargets: [research-agent, code-agent]
  maxDepth: 2   # Sub-agents cannot spawn further sub-agents

4. Production infrastructure included

Open Astra ships with the infrastructure concerns that most agent frameworks leave to you:

• Multi-tenant auth — JWT-based workspace isolation out of the box
• 10 LLM providers — Grok, Groq, OpenAI, Gemini, Claude, Ollama, vLLM, Bedrock, Mistral, OpenRouter — with per-provider prompt caching
• Self-healing — exponential backoff restart on failures, automatic context compaction at 85% token limit
• Diagnostics — 12 checks across 6 categories via npx astra doctor
• Cost tracking — per-agent token usage and cost dashboard via npx astra costs
• 15 messaging channels — Telegram, Discord, Slack, WhatsApp, Signal, iMessage, Google Chat, Microsoft Teams, LINE, Viber, X, Email, Linear, Jira, Zapier
• Typed event bus — every agent action emits a Zod-validated event you can subscribe to or forward as webhooks

Open Astra vs other frameworks

Open Astra is a backend runtime for teams: multi-tenant, API-first, and built for infrastructure you deploy and own. Here's how it compares to popular alternatives:

5. No black boxes, no blind trust

Open Astra ships zero community plugins and zero external MCP servers. Every tool, skill, inference adapter, and memory operation in your deployment is code you can read, audit, and modify. There are no marketplace extensions phoning home. There are no hosted MCP servers running proprietary code between your data and your agent. If something runs in your agent loop, it is in this repository.

• No plugin registry — there is no mechanism to install unreviewed third-party tools at runtime
• No opaque MCP intermediaries — all tool execution happens in-process, in code you own
• Self-hostable end-to-end — Postgres, Typesense, inference APIs — nothing requires trusting an external service you cannot inspect
• Auditable tool surface — the full tool registry is in src/tools/index.ts; what is imported is what runs
• Auditable design — inspect the architecture and verify behavior before running it in production