Give your AI agents a nervous system

The problem nobody talks about

AI agents are getting more capable every month. But they're all amnesiacs. Every session starts from zero — no awareness of what happened last time, no memory of decisions made, no understanding of what other agents are doing right now.

Memory products exist (Mem0, Letta, Zep), but they solve a different problem. They store facts. What's missing is coordination — a shared awareness layer that lets agents know what's happening, what just changed, and what they should do next.

I had this problem at scale. My system runs 95+ tools across 6 different interfaces: a web dashboard, a CLI, a conversational assistant, a trading terminal, a creative writing mode, and an orchestration layer. Multiple AI agents work concurrently. Without shared awareness, they step on each other.

What Vigil does

Vigil is the nervous system I extracted from that production stack. It gives agents five capabilities they don't normally have:

• ▸Signals — structured observations with type-based content budgets. Observations, handoffs, summaries, alerts. Any agent can emit, any agent can read.
• ▸Awareness daemon — compiles recent signals into a hot context snapshot every 90 seconds. Agents boot with awareness instead of starting blind.
• ▸Session handoff — structured chains that carry what happened, what files changed, what decisions were made, and what to do next.
• ▸Knowledge base — persistent facts that survive signal compaction. Signals are ephemeral. Knowledge accumulates.
• ▸Event triggers — pattern-matching rules that fire actions (webhooks, signals, focus items) when incoming signals match.

Three ways to connect

Vigil ships with three transport modes, all sharing the same SQLite database:

The MCP server exposes 15 tools. The REST API adds 25 endpoints with Bearer auth. Both include an embedded dashboard with live htmx updates — awareness state, agent activity, signal feed, handoff chains, and frame maps.

The CLI is the real product

Every feature is accessible from the command line. This matters because most AI agent workflows happen in terminals.

What makes it different

I looked at every agent coordination tool I could find before building this. Mem0 stores facts in a knowledge graph. Letta gives agents self-editing memory. Zep tracks temporal knowledge. LangGraph and CrewAI orchestrate agent workflows.

None of them solve the awareness problem. They don't have a background daemon that compiles system state. They don't have frame-based filtering that cuts token overhead by 50-90%. They don't have structured handoff chains. They don't have event triggers that fire actions on signal patterns.

Vigil isn't competing with memory products. It's the layer that sits above them — coordinating awareness so agents know what's happening, not just what happened.

From library to cloud platform

The open-source library proved the patterns work. But most teams don't want to run their own infrastructure. So I built Vigil Cloud — a hosted platform at app.vigil-agent.com that runs a fully isolated Vigil instance per tenant.

The hosted tier adds GitHub OAuth for login, per-tenant SQLite isolation with LRU-cached connections, API key authentication with SHA-256 hashed storage, usage metering, and Stripe billing. Three paid tiers: Pro ($9/mo), Team ($29/mo), Enterprise ($99/mo). Each tenant gets their own awareness daemon, signal history, and knowledge base — zero shared state.

I built the entire multi-tenant backend in a single session: 1,295 lines across 11 files in the hosted package. Platform DB for accounts and billing, tenant isolation layer, OAuth flow, dashboard with usage stats and key management, Stripe checkout and webhook handling. First production signal recorded the same night.

By the numbers

v2.0 is live. 9,200+ lines across 14 modules, 268 tests. The open-source core is on PyPI with zero external dependencies — just Python and SQLite. The hosted tier runs at app.vigil-agent.com. A Python SDK (vigil-client) wraps the REST API for programmatic access.