---
One company. One agent memory.

Steward
ACS

Right now, every person's agent is a silo. Steward gives your whole company one shared memory.

Person A's Claude learns it today. Person B's Claude uses it tomorrow. One organizational memory.

Every person in your company has their own agent — and every agent forgets everything when the session ends. Steward gives your entire organization a single persistent memory that every agent reads from and writes to. Patterns, decisions, code conventions, API knowledge — once one person's agent learns it, every agent in the company knows it.

L
Local Development
Single-agent or small team, SQLite, Docker Compose — clone and go.
O
Organizational Knowledge
Multi-tenant, persistent memory shared across every agent at your company. One memory, all agents.
Sign Up Free →Read Documentation
Platform capabilities
T
Task Lifecycle
Create, claim, release with auto-timeout
F
File Locking
Prevent multi-agent edit conflicts
M
Company Memory
One shared memory, every agent — no more silos
T
Multi-Tenant
Self-service orgs, per-team isolation, Auth0 SSO
S
Session Persistence
Learnings survive across every session and person
---

What is Steward?

Every person's AI agent is a silo. Steward gives your whole company one shared memory — every agent reads from it, every agent writes to it.

The problem: Person A's Claude learns your API conventions, coding patterns, and project decisions. Person B's Claude starts from scratch. Person C's GPT is building on a completely different context. Every person's agent is a silo — no shared memory, no institutional knowledge.

Steward fixes this with four core capabilities:

  1. Company-wide shared memory. A single persistent knowledge store every agent in your organization reads and writes. Save patterns, conventions, decisions, warnings — once learned, available to every agent, every person, every session.
  2. Coordination and execution. Assign, track, and manage tasks across agents so work can be distributed without duplication or conflict.
  3. Resource safety and locking. Prevents agents from "stepping on each other" by managing locks on files, state, and shared resources during execution.
  4. Cross-system integration and tooling. Exposes APIs from connected applications and generates MCP-style tools so agents interact with external services in a consistent way.

Two deployment modes:

  • Local development — clone the repo, docker compose up, SQLite, single-agent or small team. Zero configuration.
  • Organizational knowledge — multi-tenant SaaS with per-org isolation, Auth0 SSO, and persistent memory shared across every agent in your company. No more silos.

Context is pushed, not pulled:

When an agent locks a file, ACS automatically delivers the memories scoped to that file with the lock acknowledgment — no separate search needed. Agents get the right context at the right moment.

Plus, a bridge to your systems:

ACS surfaces application logs and errors directly to agents, and lets you wrap any application's REST API as an MCP tool using a simple YAML definition — no code required. Per-organization tool scoping ensures isolation.

Steward is a distributed runtime layer that enables multiple autonomous agents to operate safely and cooperatively across a shared environment — built with Elixir/Phoenix and accessible via a comprehensive set of acs_* MCP tools that any AI agent can call. No SDKs. No libraries. No vendor lock-in.

System Stack
A
AI Agents
Claude, GPT, Llama — any MCP-compatible agent
▼ acs_* tools
M
MCP Tool Gateway
YAML-defined, hot-reloadable, per-org scoping
▼
C
Core Engine (Elixir/Phoenix)
Task lifecycle, file locks, memory, presence, org registry
▼
DB
Persistence
PostgreSQL (prod) / SQLite (dev) / YAML memory store
---

How It Works

System architecture — from agents to organizational memory.

Agent Claude
Coding tasks
Agent GPT
Research tasks
Agent Llama
Analysis tasks
▼acs_* MCP tool calls▼
MCP Tool Gateway
Routes agent tool calls to handlers · per-org scoping
▼
Core Engine
Task Manager
Lifecycle + auto-release
Lock Manager
File-level locking
Memory Store
Vector + semantic search
Org Registry
Multi-tenant isolation
▼
PostgreSQL / SQLite
Persistent storage
YAML Memory Store
Persistent organizational memory
Memory Router
Per-agent + per-org scoping

Steward runs as a standalone Phoenix web application. It exposes MCP tools (acs_* prefix) that AI agents call directly. Every agent reads from and writes to the same persistent memory — so Person A's Claude and Person B's GPT share the same context. When one agent learns your API conventions, every agent in the organization knows them.

Local development mode uses SQLite with no external dependencies. Multi-tenant production uses PostgreSQL on Neon with Auth0 SSO, per-organization isolation, and optional email invitations for team members.

---

Get Started

Two ways to use Steward — choose your path.

Organizational Knowledge

Multi-tenant SaaS

Create an organization, invite your team. Every agent in your company shares one persistent memory — patterns, conventions, decisions, all accessible across every person and every session.

  • Self-service signup — no sales call needed
  • One company memory, every agent reads and writes it
  • Auth0 SSO for dashboard and MCP access
  • Kill the silos — Person A's learnings are Person B's context
  • Email invitations (optional) for team members
Sign Up Free →
Local Development

Self-hosted

Clone the repo, run Docker Compose, and point your agent at the install URL. Five automated steps, zero configuration.

  1. Create Docker ComposeCreates or updates docker-compose.steward.yml with the Steward service, SQLite, and log streaming sidecars.
  2. Create SetupWalks through 4 configuration questions (LLM provider, embeddings, database, log streaming) and generates .env-steward.
  3. Log Capture SetupConfigures Fluent Bit or direct log ingestion so ACS can collect and query logs from your apps.
  4. MCP WrappingWraps your apps' REST APIs as native MCP tools so agents can call them directly via ACS.
  5. Create AGENTS_STEWARD.mdGenerates startup instructions so every future agent that connects knows how to register and work in this project.

All 5 steps run automatically. You provide direction — the agent handles the setup.

Full setup guide →
---