Vigil — Cognitive Infrastructure for AI Agents

MCP运维云端

提供方 AlexlaGuardia

运维云端 未标注 OAuth 授权 社区 / 第三方 Claude DesktopClaudeCursorWindsurf
查看接入方式

A nervous system for AI agents — awareness daemon, frame-based tool filtering, signal protocol, session handoff, and event triggers. 14 modules, 268 tests, zero dependencies. MCP server with stdio and SSE transports.

一句话选型结论

按资料字段整理

Vigil — Cognitive Infrastructure for AI Agents 属于运维云端类 MCP 服务器,传输方式未标注,OAuth 授权,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类运维云端 传输方式未标注 鉴权OAuth 授权 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

运维云端
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

ai agents signals handoff multi agent mcp python

支持客户端

适用场景

ai agentssignalshandoff

安装与配置

未标注 OAuth 授权
上游未给出传输方式
pip install vigil-agent\r

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
云资源查询

查实例、存储、账单等云上资源状态。

部署与发布

把部署、重启、回滚这类操作接进对话。

监控与告警

拉取监控指标,异常时让模型帮你判断。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • 使用前要准备好OAuth 授权对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在运维云端场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Vigil — Cognitive Infrastructure for AI Agents当前 未标注 未标注 未标注 有 未标注
lobehub 未标注 stdio · 本地进程 本地部署 有 2026-04-11
TrendRadar 未标注 stdio · 本地进程 本地部署 有 2026-04-13
Ui Tars Desktop 8a825770 未标注 stdio · 本地进程 本地部署 有 2026-05-17
ruflo 未标注 stdio · 本地进程 本地部署 有 2026-04-13
FastGPT 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

运维云端
字段来自项目仓库与公开索引,中文说明由本站标注
提供方AlexlaGuardia上游标注的维护方 AlexlaGuardia
分类运维云端本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式OAuth 授权远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Cross-platform本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

13.6 KB
来自项目仓库与上游目录的原文,未做删改

Vigil

Observability and awareness infrastructure for AI agents.

Vigil is two layers in one package:

  • MCPWatch — the silent-failure watchdog for MCP servers. One-line instrumentation for any Python MCP server (FastMCP and low-level mcp.server.lowlevel.Server). Gateways and dashboards already give you latency and error charts. The thing nobody catches is the call that looks successful but returns nothing: empty, null, or blank content with no error raised. MCPWatch flags those as a distinct silent status, on top of per-tool latency (p50/p95/p99), error rates, and isError responses. Used in production across 95+ MCP tools.
  • Awareness platform — daemon-compiled context, signal protocol, session handoff, frame-based tool filtering, MCP server. The nervous system layer most agent frameworks skip.

Most agent memory tools are filing cabinets. Vigil is a stethoscope and a nervous system.

The Problem

MCP servers fail silently. A tool returns empty content, the SDK swallows the exception, the agent treats it as "no results found" and you find out three days later from a customer ticket. Latency and error monitoring is now table stakes (gateways, OpenTelemetry, and FastMCP itself emit it). But none of them flag the empty-but-not-errored response — the failure mode your agent quietly hallucinates around. That gap is what MCPWatch exists to close.

Agents forget everything between sessions. They load all tools regardless of context (wasting 50K+ tokens). They can't coordinate across sessions or hand off work to each other. Every conversation starts cold.

What Vigil Does

MCPWatch — the MCP silent-failure watchdog — One line wraps any Python MCP server (FastMCP or low-level mcp.server.lowlevel.Server). Its headline job: detect silent failures — calls that return empty, null, or blank content with no error raised — and record them as a distinct silent status that shows up in health, per-tool stats, and alerts. It also tracks tool-call latency (p50/p95/p99), per-tool error rates, isError responses, and call volume over time. REST API, CLI, and alert hooks. MIT, no config required.

Awareness Daemon — A background process compiles system state every 90 seconds. Agents boot with pre-compiled context in <1 second. No startup latency, no "remind me what we were doing."

Frame-Based Tool Filtering — Tag tools with context frames. An agent in "backend" mode sees 14 tools, not 95. Saves 50-90% of tool-definition tokens per session.

Signal Protocol — Lightweight event bus with content budgets. Agents emit signals (max 300-800 chars by type), the daemon synthesizes them into awareness. Agents coordinate without direct communication.

Session Handoff — Agents end sessions with structured summaries (files touched, decisions, next steps). The next agent boots with full context of what happened and what to do next.

Signal Compaction — Old signals get summarized, not deleted. Tiered retention (raw → daily → weekly → monthly) keeps context fresh without losing history.

MCP Server — Expose Vigil as an MCP tool server. Any Claude Code, Claude Desktop, Cursor, or Windsurf agent connects and gets persistent awareness instantly.

Articles

  • Your MCP Servers Are Flying Blind (Here's How to Fix It) — MCPWatch deep dive on Dev.to

Install```bash

Core library (daemon, signals, handoff, compaction)

pip install vigil-agent

With MCP server support

pip install vigil-agent[mcp]


## 30-Second Demo

See Vigil work in four commands:```bash
pip install vigil-agent
vigil init
vigil signal my-agent &quot;Hello from Vigil!&quot;
vigil status

Expected output:```
Current Awareness
─────────────────
Agents: my-agent (1 signal)
Latest: "Hello from Vigil!" (just now)
Frame: default
Status: active — 1 unacknowledged signal


That&#x27;s it — your agent has awareness. Read on for the full quickstart with daemon, handoff, and MCP server.

## Quickstart```bash
# Initialize
vigil init

# Emit a signal
vigil signal my-agent &quot;Deployed new API endpoint&quot;

# Start the daemon (compiles awareness every 90s)
vigil daemon start

# Check awareness
vigil status

# See what agents boot with
vigil boot --json

# End a session with a structured handoff
vigil handoff my-agent &quot;Shipped auth module&quot; --files &quot;auth.py, tests.py&quot; --next-steps &quot;Write docs&quot;

# Resume from where the last agent left off
vigil resume next-agent

# Start as an MCP server (Claude Code / Claude Desktop)
vigil serve

# Run signal compaction manually
vigil compact --dry-run

MCP Server

Vigil runs as an MCP server so any AI agent can connect and get persistent awareness.```bash

stdio (Claude Code, Claude Desktop)

vigil serve

SSE (remote clients)

vigil serve --transport sse --port 8300


**Claude Desktop config** (`claude_desktop_config.json`):```json
{
  &quot;mcpServers&quot;: {
    &quot;vigil&quot;: {
      &quot;command&quot;: &quot;vigil&quot;,
      &quot;args&quot;: [&quot;serve&quot;]
    }
  }
}

12 MCP tools available:

Tool Description
vigil_boot Boot with pre-compiled hot context
vigil_compile Force a fresh awareness compilation
vigil_signal Emit a signal from an agent
vigil_status Get current awareness state
vigil_signals Read recent signals
vigil_handoff End session with structured handoff
vigil_resume Resume from last handoff
vigil_chain Get briefing of last N handoffs
vigil_stale Find agents that have gone silent
vigil_focus Manage priority work queue
vigil_frames Manage context frames
vigil_agents List known agents and activity

Python API```python

from vigil import VigilDB, SignalBus, AwarenessCompiler, HandoffProtocol

Initialize

db = VigilDB("vigil.db")
bus = SignalBus(db)
compiler = AwarenessCompiler(db)
proto = HandoffProtocol(db)

Emit signals from agents

bus.emit("backend-agent", "Deployed auth service v2")
bus.emit("frontend-agent", "Updated dashboard layout")

Compile awareness

compiler.synthesize()
context = compiler.compile()

{'frame': 'backend', 'awareness': '...', 'focus': [...], 'compiled_at': '...'}

Boot an agent with pre-compiled context (<1 second)

hot_context = compiler.boot()

Structured session handoff

proto.end_session(
agent_id="backend-agent",
summary="Shipped auth v2 with JWT tokens",
files_touched=["auth.py", "middleware.py"],
decisions=["Switched from session cookies to JWT"],
next_steps=["Add rate limiting", "Write integration tests"],
)

Next agent resumes with full context

context = proto.resume("next-agent")

{'awareness': ..., 'last_handoff': {...}, 'signals_since_handoff': [...], 'pending_next_steps': [...]}


### Frame-Based Tool Filtering```python
from vigil.registry import tool, get_tools, tool_count

# Tag tools with frames
@tool(name=&quot;deploy&quot;, description=&quot;Deploy to production&quot;, frames=[&quot;backend&quot;, &quot;devops&quot;])
async def deploy(args):
    return {&quot;content&quot;: [{&quot;type&quot;: &quot;text&quot;, &quot;text&quot;: f&quot;Deployed {args[&#x27;service&#x27;]}&quot;}]}

@tool(name=&quot;render&quot;, description=&quot;Render component&quot;, frames=[&quot;frontend&quot;])
async def render(args):
    ...

@tool(name=&quot;health&quot;, description=&quot;Health check&quot;, frames=[&quot;core&quot;])  # Always visible
async def health(args):
    ...

# Filter by context
tool_count()              # 3 (all tools)
tool_count(&quot;backend&quot;)     # 2 (deploy + health)
tool_count(&quot;frontend&quot;)    # 2 (render + health)

Signal Compaction```python

from vigil import SignalCompactor

compactor = SignalCompactor(db)

Run compaction (tiered: raw → daily → weekly → monthly)

stats = compactor.compact()

{'daily_summaries': 5, 'weekly_digests': 2, 'monthly_snapshots': 1, 'signals_compacted': 47}

Browse compacted history

history = compactor.get_history(days=30, agent="backend-agent")


### Signal Types &amp; Budgets

| Type | Budget | Use |
|------|--------|-----|
| `observation` | 400 chars | Regular activity updates |
| `handoff` | 600 chars | Session conclusions |
| `summary` | 800 chars | Comprehensive summaries |
| `alert` | 300 chars | Urgent notifications |

## Architecture```
Agents emit signals → SQLite → Daemon compiles → Hot context → Agents boot instantly
                                    ↓
                            Frame detection
                            Awareness synthesis
                            Signal compaction
                            Focus queue
  • Zero infrastructure — SQLite storage, no Redis/Postgres/Docker required
  • Framework-agnostic — Works with any MCP-compatible client, or standalone
  • Lightweight — Pure Python, no heavy dependencies (mcp is optional)

Integrations

Ready-to-use configs for popular AI tools. See the examples/ directory for full setup guides.

Tool Setup
Claude Code claude mcp add vigil -- vigil serve (guide)
Claude Desktop Add to claude_desktop_config.json (guide)
Cursor Add to .cursor/mcp.json (guide)
GitHub Actions Emit signals from CI/CD (workflow)
Slack Route alerts to Slack via triggers (guide)
Discord Route alerts to Discord via triggers (guide)

Shell Completion```bash

Bash

source completions/vigil.bash

Zsh

cp completions/vigil.zsh ~/.zsh/completions/_vigil


## CLI Reference

| Command | Description |
|---------|-------------|
| `vigil init` | Initialize a new project |
| `vigil quickstart` | Interactive setup wizard |
| `vigil daemon start` | Start the awareness daemon |
| `vigil daemon status` | Check daemon compilation status |
| `vigil serve` | Start as MCP server (stdio or SSE) |
| `vigil signal  ` | Emit a signal |
| `vigil status` | Show current awareness |
| `vigil boot` | Show compiled hot context |
| `vigil frames` | List registered frames |
| `vigil tools [--frame X]` | List tools (optionally filtered) |
| `vigil handoff  ` | Write a structured session handoff |
| `vigil resume ` | Resume from last handoff |
| `vigil history` | Browse compacted signal history |
| `vigil agents` | List known agents |
| `vigil compact` | Run signal compaction manually |
| `vigil know  ` | Store a knowledge entry |
| `vigil recall ` | Fuzzy-search knowledge |
| `vigil knowledge` | List all knowledge entries |
| `vigil forget ` | Delete a knowledge entry |
| `vigil extract` | Auto-extract knowledge from signal patterns |
| `vigil export` | Export state to markdown |
| `vigil mcp-health` | MCP server health (calls, errors, latency) |
| `vigil mcp-health-check ` | Probe MCP server in CI (exit 0/1) |
| `vigil doctor` | Diagnose common issues |
| `vigil version` | Show version |

## MCP Production Observability

Monitor any MCP server with one line of code. Tracks tool calls, latency, errors, and emits alerts automatically.```python
from mcp.server.fastmcp import FastMCP
from vigil.mcpwatch import instrument

mcp = FastMCP(&quot;my-server&quot;)

@mcp.tool()
async def search(query: str) -&gt; str:
    return &quot;results&quot;

# One line — all tools are now monitored
watch = instrument(mcp)

What it monitors:
- Silent failures — calls that return empty, null, or blank content with no error raised. Recorded as a distinct silent status, surfaced in health and stats, and alerted on. This is the headline feature.
- Every tool call: name, duration, success / error / silent
- Latency spikes (configurable threshold, default 5s)
- Error patterns with full tracebacks (including low-level isError responses)
- Server silence (no calls at all for N minutes)

Three ways to use it:```python

1. Local Vigil — store in same DB as your signals

watch = instrument(mcp, db_path="vigil.db")

2. Vigil Cloud — send to your hosted instance

watch = instrument(mcp, api_key="vgl_...")

3. Memory-only — just in-process stats

watch = instrument(mcp)


**Check health anytime:**```python
health = watch.health()
# {&#x27;server&#x27;: &#x27;my-server&#x27;, &#x27;status&#x27;: &#x27;degraded&#x27;, &#x27;total_calls&#x27;: 1247,
#  &#x27;total_errors&#x27;: 25, &#x27;error_rate&#x27;: 0.02,
#  &#x27;total_silent&#x27;: 140, &#x27;silent_rate&#x27;: 0.112,   # &lt;- the failures nobody else flags
#  &#x27;tools&#x27;: {&#x27;search&#x27;: {&#x27;avg_ms&#x27;: 42, &#x27;p95_ms&#x27;: 180, &#x27;silent_count&#x27;: 140}}}

watch.recent_silent()   # the actual empty/null calls, per tool

A tool that returns &quot;&quot;, None, or [] with no exception is the classic MCP
blind spot — the SDK reports success, your agent improvises around the void.
MCPWatch turns that into a first-class signal.

CLI:bash vigil mcp-health # All monitored servers vigil mcp-health -s my-server # Specific server

REST API (6 endpoints):

Endpoint Description
GET /mcp/health Server health summary (incl. silent rate)
GET /mcp/tools Per-tool analytics
GET /mcp/silent Recent silent failures (empty/null returns)
GET /mcp/errors Recent errors
GET /mcp/latency p50/p95/p99 percentiles
GET /mcp/volume Call volume over time

Why Not Just Use Mem0/Letta/LangGraph?

Vigil Mem0 Letta LangGraph
Approach Awareness daemon Memory retrieval Stateful runtime State machine
Context Pre-compiled, instant boot Query on demand LLM-managed Checkpoint-based
Tool filtering Frame-based (50-90% savings) None None None
Multi-agent Signal protocol + handoff Shared memory Single agent Graph edges
Compaction Tiered (daily/weekly/monthly) None LLM-managed None
MCP native Built-in server No No No
Infrastructure SQLite (zero setup) API + LLM costs Full runtime LangChain ecosystem
Lock-in None (framework-agnostic) Mem0 API Letta platform LangChain

Vigil is the nervous system. Others are the filing cabinet. Use them together — Vigil handles awareness and coordination, Mem0/Letta handles deep memory.

License

MIT

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
Vigil — Cognitive Infrastructure for AI Agents 怎么安装?

在客户端按下面的安装命令接入:pip install vigil-agent\r。装完在客户端配置里引用同一个包或端点。

Vigil — Cognitive Infrastructure for AI Agents 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Vigil — Cognitive Infrastructure for AI Agents 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Vigil — Cognitive Infrastructure for AI Agents 需要 API Key 吗?

资料标注需要OAuth 授权认证,使用前准备好对应凭据,并按最小权限配置。

Vigil — Cognitive Infrastructure for AI Agents 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、Windsurf、Gemini CLI、Codex;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Vigil — Cognitive Infrastructure for AI Agents 能提供哪些能力?

资料显示能力标签包括 ai agents、signals、handoff、multi agent、mcp、python。具体工具清单以官方文档为准。

Vigil — Cognitive Infrastructure for AI Agents 需要什么运行环境?

运行时为 Cross-platform。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。