phantom

MCP运维云端

提供方 ghostwright · 包名 phantom

运维云端 stdio · 本地进程 未标注 社区 / 第三方 Claude DesktopCursorClineClaude Code
查看接入方式

An AI co-worker with its own computer. Self-evolving, persistent memory, MCP server, secure credential collection, email identity. Built on the Claude

一句话选型结论

按资料字段整理

phantom 属于运维云端类 MCP 服务器,stdio · 本地进程,鉴权方式未标注,可直接接入 Claude Desktop、Cursor、Cline 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

phantom ai-agents ai-coworker anthropic autonomous-agents

支持客户端

适用场景

phantomai-agentsai-coworker

安装与配置

stdio · 本地进程 未标注
客户端在本机拉起子进程,数据不出本机
npx -y phantom

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

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Cross-platform,再按安装命令拉取依赖。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

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

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

部署与发布

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

监控与告警

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

选择建议

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

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Cursor、Cline,换客户端不用重新研究配置。
  • 仓库有一定关注度(星标 1,259),遇到问题更容易搜到资料。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
phantom当前 未标注 stdio · 本地进程 本地部署 有 2026-04-12
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

服务器档案

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

详细介绍

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

Phantom

An AI co-worker with its own computer.

Website ·
Get a Free Phantom ·
Docs ·


The Idea

AI agents today are disposable. You open a chat, get an answer, close the tab, and the context is gone. Next time you start from scratch. Every session is day one.

Phantom takes a different approach: give the AI its own computer. A dedicated machine where it installs software, spins up databases, builds dashboards, remembers what you told it last week, and gets measurably better at your job every day. Your laptop stays yours. The agent's workspace is its own.

This is not a chatbot. It is a co-worker that runs on Slack, has a web chat interface at /chat, has its own email address, creates its own tools, and builds infrastructure without asking for permission. Don't take our word for it - scroll down to see what production Phantoms have actually built.

What This Actually Looks Like

These are not mockups. They happened on production Phantom instances.

Built an analytics platform from scratch

A Phantom was asked to help with data analysis. It installed ClickHouse on its own VM, downloaded the full Hacker News dataset, loaded 28.7 million rows spanning 2007-2021, built an analytics dashboard with interactive charts, and created a REST API to query the data. Then it registered that API as an MCP tool so it could use it in future sessions and other agents could query it too.

Nobody asked it to build any of this. It identified analytics as useful and built the entire stack.

28.7 million items. 755K unique authors. 4.3 million stories. Built, loaded, and served by a Phantom on its own machine.

Extended itself with a channel it was never built with

Phantom ships with Slack, Telegram, Email, and Webhook channels. It does not ship with Discord. When asked "Can I talk to you on Discord?", the Phantom said: "Not right now. Discord isn't wired up. That said, I could build it."

It explained the Discord Bot API, walked the user through creating a Discord application, provided a magic link for secure token submission, and said: "Once you save it, I'll automatically spin up the container and you'll be live on Discord."

After submitting the token, Phantom went live on Discord. It permanently gained a communication channel it was never designed with.

The agent was honest about what it could not do, then built the capability on the spot.

Started monitoring its own infrastructure

A Phantom discovered Vigil, a lightweight open-source system monitor with 3 GitHub stars. It understood what Vigil does, integrated it into its existing ClickHouse instance, built a sync pipeline that batch-transfers metrics every 30 seconds, and created a real-time monitoring dashboard showing service health, Docker container status, network I/O, disk I/O, system load, and data pipeline health.

890,450 rows. 25 metrics. Auto-refreshing. The agent is watching its own infrastructure.

It found a 3-star open-source project, integrated it into its data pipeline, and built observability for itself.


This is what happens when you give an AI its own computer.

Bring Your Own Model

Phantom is not locked to any single AI backend. It ships with support for seven providers out of the box, configured through a single YAML block:

  • Anthropic (default) - Claude Opus, Sonnet, Haiku
  • Z.AI - GLM-5.1 and GLM-4.5-Air via Z.AI's Anthropic-compatible API. Roughly 15x cheaper than Claude Opus for comparable coding quality.
  • OpenRouter - 100+ models through one key
  • Ollama - Any GGUF model on your own GPU, zero API cost
  • vLLM - Self-hosted inference with OpenAI-compatible endpoints
  • LiteLLM - Local proxy bridging OpenAI, Gemini, and more
  • Custom - Any Anthropic Messages API compatible endpoint

Switching providers is two lines of YAML:```yaml

phantom.yaml

model: claude-opus-4-7
provider:
type: zai
api_key_env: ZAI_API_KEY
model_mappings:
sonnet: glm-5.1


Set `ZAI_API_KEY` in `.env`, restart, done. Both the main agent and every evolution judge flow through the chosen provider from that point on. The tools are the same, the memory is the same, the self-evolution pipeline is the same. Only the brain changes.

Anthropic stays the default. Existing deployments continue to work with no configuration changes. See docs/providers.md for the full reference.

## Quick Start

### Docker (recommended)```bash
curl -fsSL https://raw.githubusercontent.com/ghostwright/phantom/main/docker-compose.user.yaml -o docker-compose.yaml
curl -fsSL https://raw.githubusercontent.com/ghostwright/phantom/main/.env.example -o .env
# Edit .env - add your ANTHROPIC_API_KEY, Slack tokens, and OWNER_SLACK_USER_ID
docker compose up -d

Your Phantom is running. Qdrant starts for memory, Ollama pulls the embedding model, and the agent boots. Check health at http://localhost:3100/health. With Slack configured, it DMs you when it's ready. Add RESEND_API_KEY for email sending. See Getting Started for full setup.

> Security note, Docker socket mount: docker-compose.yaml mounts
> /var/run/docker.sock into the Phantom container so it can spawn sibling
> containers (e.g. sandboxed code execution). This is an intentional
> architectural trade-off: the socket grants the container root-equivalent
> access to the Docker daemon
, which means a compromised Phantom process
> could create, modify, or destroy any container on the host. Mitigations:
> run Phantom on a dedicated machine or VM (not your personal workstation),
> and do not expose the host's Docker socket to untrusted workloads. See
> docs/security.md for the full threat model.

Managed (free)

Get a Phantom on a dedicated VM with nothing to install. Bring your Anthropic API key, we give you the machine.

ghostwright.dev/phantom

What People Build with Phantom

Phantom is not just for engineers. It is for anyone who wants an AI that remembers, learns, and builds things you can actually share.

The key difference: when an AI runs on your laptop, everything it builds is trapped on localhost. Only you can see it. Phantom runs on a VM with a public domain. Dashboards, tools, pages, APIs - they all get a URL you can send to your team, your manager, or your clients. Your laptop is not a server. Phantom's VM is.

For People Who Don't Write Code

You don't need to install developer tools, learn a build system, or figure out hosting. You describe what you want in Slack. Phantom builds it, deploys it on its own machine, and gives you a link.

  • "Build me a Chrome extension that highlights overdue emails." Phantom builds it and gives you a zip file. You drag it into Chrome. No Xcode, no npm, no terminal. Just install it and go.
  • "Make a landing page for my side project." Phantom builds the page, serves it on its public domain, and gives you a URL. Send it to anyone. No hosting setup, no domain configuration.
  • "Create a weekly report of our open support tickets." Phantom builds the automation, runs it on a schedule, and emails you the summary every Friday from its own email address.
  • "Build a form where the team can submit feature requests." Phantom creates it on its domain, handles submissions, and routes them to Slack.

Software Engineering

  • Morning standup: "Every weekday at 9am, summarize open PRs, CI status, and what needs review." Phantom checks GitHub, compiles the summary, and posts it to your team channel.
  • Codebase onboarding: "Clone this repo and give me an architecture overview." Phantom reads the code and returns specifics, not generics. "Next.js 16 with App Router, Drizzle ORM on Neon Postgres, flaky step in the migration check."
  • Infrastructure: "Set up a dev Postgres for this project." Phantom spins up a Docker container on its own machine, creates the schema, runs migrations, and gives you a connection string. Nothing installed on your laptop.
  • Data pipelines: "Pull from our API every hour and load into Postgres." Phantom builds the pipeline, runs the database on its VM, and schedules the cron. You get a connection string.
  • Custom MCP tools: "Create an MCP tool that queries our internal API." Phantom builds the tool, registers it, and any Claude Code instance connected to it can call it immediately.

Sales and Account Management

  • Prospect research: "Research these 10 companies and build outreach strategies." Phantom gathers intelligence, identifies decision-makers, and creates briefing pages you can share with your team.
  • Recruiting profiles: "Make a profile page for this candidate." Phantom researches the person and builds a public profile page you can send to hiring managers. Shareable URL with auth.
  • Competitor monitoring: "Every 2 minutes, check for open-source repos similar to our product." Phantom runs a cron job, tracks new entrants, and posts updates to Slack.

Data and Analytics

  • Build your own analytics stack: Phantom installs databases, builds ETL pipelines, and registers APIs as MCP tools for future sessions. All on its own machine. (See the ClickHouse story above.)
  • Shareable dashboards: "Track our PR velocity and show it to the team." Phantom builds an ECharts dashboard, serves it on a public URL with auth, and sends you the link. Your team bookmarks it. They see the same thing you see.
  • Data exploration: "Load this dataset and let me ask questions about it." Phantom creates a queryable environment on its VM. You ask in plain English, it translates to SQL.

Operations, Marketing, and Everyone Else

  • Automated reports: "Email a weekly summary of open issues to team leads every Friday." Phantom compiles the report and sends it from its own email address.
  • Competitor watching: "Monitor these five websites for changes and tell me when something updates." Phantom checks on a schedule and notifies you in Slack.
  • Blog drafts: "Write a post based on our recent product updates." Phantom reads the changelog, writes the draft, and serves it as a page you can review and share with your editor.
  • Personal coaching: "Create a training plan for me." Phantom builds a complete plan with a coach persona, served as a page you can reference daily.

For Everyone

  • Remembers what you told it last Monday and uses it on Wednesday.
  • Never asks the same question twice.
  • Gets measurably better at YOUR job every day, not just at being a generic assistant.

How It's Different

Most AI assistants run on your computer, share your resources, and forget everything between sessions. Phantom was designed around a different assumption: the agent should have its own workspace.

Traditional (runs on your machine) Phantom (its own machine)
Your computer Shared with the agent Yours alone
Security Agent can access your full filesystem Isolated VM, you control what it sees
Credentials Often stored in plain text config files AES-256-GCM encrypted, collected via secure forms
Sharing Trapped on localhost, nobody else can see it Public URL with auth, share with anyone
Tools Fixed set, defined at install time Creates its own tools at runtime, persists them across restarts
Availability Only when your machine is on 24/7, runs in the cloud
Cost Uses your CPU and memory $7-20/month for a dedicated VM

Why This Matters

"Why does it need its own computer?"

Because you can have an 8GB laptop and give your agent 64GB of RAM for $20/month. Because it can install software, spin up databases, and run services without touching your machine. Because it is always on, even when your laptop is closed. Because everything it builds has a public URL - dashboards, APIs, pages, tools - that you share with a link. Your laptop cannot do that. It does not have a public IP. Phantom's VM does.

"Why does self-evolution matter?"

Because Day 1 Phantom is generic. Day 30 Phantom knows your codebase, your deploy process, your PR conventions, and the fact that your biggest client always asks about uptime before renewal. You never repeat yourself. The agent observes, reflects, proposes changes, validates them through a different model (to avoid self-enhancement bias), and evolves. Every version is stored. You can roll back.

"Why do dynamic tools matter?"

Because the agent that can only use pre-built tools hits a ceiling. Phantom builds what it needs. One Phantom built a send_slack_message tool, registered it, and retired its old workaround. That tool survives restarts. Other agents connecting via MCP can use it too.

Features

Feature Why it matters
Its own computer Your laptop stays yours. The agent installs software, runs 24/7, and builds infrastructure on its own machine.
Bring your own model Anthropic, Z.AI (GLM-5.1), OpenRouter, Ollama, vLLM, LiteLLM, or any Anthropic Messages API compatible endpoint. Pick your backend in YAML, same agent everywhere.
Self-evolution The agent rewrites its own config after every session, validated by LLM judges. Day 30 knows things Day 1 didn't.
Persistent memory Three tiers of vector memory. Mention something on Monday, it uses it on Wednesday. No re-explaining.
Dynamic tools Creates and registers its own MCP tools at runtime. Tools survive restarts and work across sessions.
Encrypted secrets AES-256-GCM encrypted forms with magic-link auth. No plain-text credentials in config files.
Email identity Every Phantom has its own email address. Send reports to people outside your Slack workspace.
Web chat A full browser-based chat client at /chat with SSE streaming, file attachments, and Web Push notifications. No Slack required.
Shareable pages Generates dashboards and tools on a public URL with auth. Share a link, anyone can see it.
MCP server Claude Code connects to your Phantom. Other Phantoms connect to your Phantom. It is an API, not a dead end.

Architecture```

        External Clients

Claude Code | Dashboard | Other Phantoms
|
MCP (Streamable HTTP)
|
+------------------------------------------+
| PHANTOM (Bun process) |
| |
| Channels Agent Runtime |
| Slack query() + hooks |
| Web Chat Prompt Assembler |
| Telegram base + role + evolved |
| Email + memory context |
| Webhook / CLI |
| |
| Memory System Self-Evolution Engine |
| Qdrant 6-step pipeline |
| Ollama 5-gate validation |
| 3 collections LLM judges (optional) |
| |
| MCP Server Role System |
| 8 universal YAML-first roles |
| + role tools Onboarding flow |
| + dynamic Evolution focus |
+------------------------------------------+
| |
+---------+ +---------+
| Qdrant | | SQLite |
| Docker | | Bun |
+---------+ +---------+


## Connect from Claude

First, generate a token. The command outputs a bearer token. Save it for the next step.

**Bare metal:**```bash
bun run phantom token create --client claude-code --scope operator

Docker:```bash
docker exec phantom bun run phantom token create --client claude-code --scope operator


**Or just ask your Phantom in Slack:** "Create an MCP token for Claude Code." It will generate the token and give you the config snippet.

Then use the token to connect. Replace `YOUR_TOKEN` below with the token from the command above. For local instances, use `http://localhost:3100/mcp` instead of the `ghostwright.dev` URL.

### Claude Code (CLI)

Add via the CLI:```bash
claude mcp add phantom https://your-phantom.ghostwright.dev/mcp \
  --transport http \
  --header "Authorization: Bearer YOUR_TOKEN"

Or add directly to your project's .mcp.json:```json
{
"mcpServers": {
"phantom": {
"type": "http",
"url": "https://your-phantom.ghostwright.dev/mcp",
"headers": {
"Authorization": "Bearer YOUR_TOKEN"
}
}
}
}


### Claude Desktop

Claude Desktop only supports stdio transport, so you need `mcp-remote` to bridge the connection.

Add this to your `claude_desktop_config.json` (Settings → Developer → Edit Config):```json
{
  "mcpServers": {
    "phantom": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://your-phantom.ghostwright.dev/mcp",
        "--header",
        "Authorization: Bearer YOUR_TOKEN"
      ]
    }
  }
}

Restart Claude Desktop after saving. The first connection may take a moment while mcp-remote is downloaded.

Verify

Once connected, Claude can query your Phantom's memory, ask it questions, check status, and use any dynamic tools the agent has built.

Self-Evolution

The core differentiator. After every session:

  1. Observe - extract corrections, preferences, and domain facts from the conversation
  2. Critique - compare session performance against current config
  3. Generate - propose minimal, targeted config changes
  4. Validate - 5 gates: constitution, regression, size, drift, safety
  5. Apply - write approved changes, bump version
  6. Consolidate - periodically compress observations into principles

Safety-critical gates use Sonnet as the default cross-model judge (main runs on Opus, so judges run on Sonnet to avoid self-enhancement bias). Operators may opt into Opus judges explicitly for deeper reasoning at higher cost. Triple-judge voting with minority veto: one dissenting judge blocks the change. Every version is stored. You can diff day 1 and day 30. You can roll back.

The Ghostwright Ecosystem

Phantom is the fourth product in the Ghostwright family:

  • Ghost OS - MCP server for macOS accessibility and screen perception
  • Shadow - ambient capture and recall for Mac
  • Specter - VM provisioning on Hetzner with DNS, TLS, and systemd
  • Phantom - the autonomous co-worker

Development Setup```bash
git clone https://github.com/ghostwright/phantom.git
cd phantom
bun install

Start vector DB and embedding model

docker compose up -d qdrant ollama
docker exec phantom-ollama ollama pull nomic-embed-text

Initialize config

bun run phantom init --yes

Set your API key

export ANTHROPIC_API_KEY=sk-ant-...

Start

bun run phantom start
```bash bun test # 1584 tests bun run lint # Biome bun run typecheck # tsc --noEmit

See docs/getting-started.md for detailed Slack setup, .env configuration, VM deployment, and troubleshooting.

Contributing

We need help with new role templates, channel integrations, memory strategies, and testing across environments. If you are building AI agents that learn and improve, this is the project.

See CONTRIBUTING.md for guidelines.

License

Apache 2.0. Use it, modify it, deploy it, build on it. See LICENSE.

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
phantom 怎么安装?

在客户端按下面的安装命令接入:npx -y phantom。对应的包名是 phantom。装完在客户端配置里引用同一个包或端点。

phantom 怎么在 Claude Desktop、Cursor、Cline 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

phantom 收费吗?

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

phantom 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

phantom 支持哪些客户端?

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

phantom 能提供哪些能力?

资料显示能力标签包括 phantom、ai-agents、ai-coworker、anthropic、autonomous-agents。具体工具清单以官方文档为准。

phantom 需要什么运行环境?

运行时为 Cross-platform;属于本地进程,需要在本机装好运行环境。

phantom 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

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

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