Ghost Agent (Coreon MCP Execution Engine)

An MCP execution engine that decouples agent planning from tool execution: natural language in, structured tool-chain results out, runnable via CLI, HTTP API, or Telegram.

Stars
★ 741
Last updated
2mo ago
License
MIT
Primary language
Shell

At a glance

How it runs
CLISelf-hosted serviceChat bot
Works with
Portable with changesOpenAI APIClaude Code (Partial support)
Cost
Free software; you pay for model usage
Setup effort
Low · running in minutes
You'll need
DockerPython 3.11+OpenAI API keyShell / CLINetwork accessLocal filesystemMCP Server
Typical use
Web3 developers querying Solana balances, token metadata, and DeFi data from the command line via natural language
Not a fit if
  • Users wanting zero paid API keys; you must supply your own OpenAI key
  • Anyone needing autonomous agent payments or automated on-chain swaps today

What does this agent do, and when should you use it?

The core product of the Ghost-Agent repository is Coreon-MCP-Execution-Engine, a unified runtime for structured ToolCall chains. It consists of four modules: a Planner that uses LLM-based intent recognition to turn natural language into a JSON execution plan, an Executor that runs tools sequentially (or in parallel) with retries, error recovery and logging, a Tool Registry that centrally declares each tool's name, module, function signature and schema, and Connectors offering CLI, API-server and Telegram-bot entry points. The engine ships as a Docker image with zero local dependencies and needs only MCP_LANG and OPENAI_API_KEY to start. Built-in tools cover DexScreener and Binance market data, CryptoPanic news, social metrics, and on-chain APIs, with an explicit focus on the Solana ecosystem as an AI execution layer for Web3. The README also outlines an MCP payment-signal protocol integration on Solana, with autonomous agent payments still in development.

Accepts natural-language input from CLI, Telegram, or HTTP API; the Planner performs LLM-based intent recognition and emits a JSON ToolCall chain; the Executor runs tools step-by-step or in parallel, handling retries, error recovery and logging; the Tool Registry declares each tool's name, module, function and schema so new tools plug in without changing execution logic; built-in tools include market data (DexScreener/Binance), news (CryptoPanic), social metrics (Twitter/Telegram), on-chain APIs (token metadata/holders), and custom utilities; a Response Formatter emits CLI charts, Telegram messages, or API JSON. On Solana it currently queries balances, token metadata, DeFi data, and contract calls; the new coreon-mcp branch adds payment-signal detection (PaymentRequired state), suspending execution and informing the user when a paid API is required.

  1. Web3 developers querying Solana balances, token metadata, and DeFi data from the command line via natural language
  2. Crypto community operators who want a Telegram bot for instant market and news lookups with no local setup
  3. Backend engineers embedding a Docker-native execution engine that separates LLM planning from tool execution
  4. Developers plugging custom tools (formatters, indicators) into crypto-analysis workflows without touching execution logic
  5. Researchers exploring agent payment economics on Solana via the MCP payment-signal protocol branch

How do you install or deploy this agent?

  1. Requirements: Python 3.11+ and Docker (install from docker.com, verify with docker --version). 2. Create a directory: mkdir mcp-execution-env && cd mcp-execution-env. 3. Generate the env file:
cat <<EOF > .env
MCP_LANG=EN
OPENAI_API_KEY=sk-xxxxxxxxxx

EOF
Replace sk-xxxxxxxxxx with your real OpenAI API key. 4. Pull the image: docker pull coreonmcp/coreon-mcp-execution-engine.

How do you use this agent?

CLI mode: docker run --rm -it --env-file .env coreonmcp/coreon-mcp-execution-engine start cli
API server mode (port 8080): docker run --rm -it --env-file .env -p 8080:8080 coreonmcp/coreon-mcp-execution-engine start server
Telegram bot mode: docker run --rm -it --env-file .env coreonmcp/coreon-mcp-execution-engine start telegram-bot

Issue tasks in natural language; the engine generates the ToolCall chain, executes it, and returns charts, messages, or JSON. The Claude-style MCP stdio mode is available in the alpha version, detailed in the Archon-Terminal repository.

What are this agent's strengths and limitations?

Pros
  • Clean four-layer architecture (Planner/Executor/Tool Registry/Connectors) with hot-pluggable tools
  • Docker-native delivery with zero local dependencies and three run modes (CLI/API/Telegram) out of the box
  • MCP payment-signal detection is implemented: execution suspends and notifies the user on a PaymentRequired state
  • Independently security-audited by Armors Labs with a public PASSED report
Limitations
  • Hard dependency on the OpenAI API (your own OPENAI_API_KEY); no adapters for other LLM providers are documented
  • Autonomous agent payments are still a roadmap item (coming soon); payment requires manual user action
  • Inconsistent naming across the README (Ghost-Agent / Archon / Coreon MCP) and links to multiple external repositories raise traceability cost
  • Solana integration is query-focused; PancakeSwap natural-language swaps, AI wallet assistants, and on-chain security monitoring remain unimplemented roadmap items

How does this agent compare with similar options?

The README positions the project as an MCP (Model Context Protocol) execution engine and notes that the alpha version officially supports the Claude-style MCP protocol (stdio mode) since 2025-09, making it comparable to invoking MCP tools directly within the Claude ecosystem.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Ghost Agent (Coreon MCP Execution Engine) This agent 27 · Major gaps CLIFree + model costs ★ 741 2mo ago Shell OpenAI API
Memoh 50 · Major gaps — ★ 2.8k today Go Codex · Claude Code
Zeroshot Verification Loop 67 · Some gaps CLIFree + model costs ★ 2.1k today Rust Codex · Claude Code
zot Coding Agent 58 · Major gaps CLIFree + model costs ★ 362 today Go OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
27/ 100 5-point scale 1.4 / 5
Trust 6/29
Reliability 3/14
Adaptability 8/18
Convention 4/18
Effectiveness 4/13
Verifiability 2/8
Why each dimension lost points
Trust6 / 29 · 1.0/5

The README describes CLI, HTTP API, Telegram, multi-tool chains, and Solana/on-chain capabilities, but provides no tool permission model, natural-language plan confirmation threshold, or pre-execution approval, so least-privilege and confirmation evidence is thin. It requires an OpenAI API key and mentions external APIs and on-chain interaction without explaining data sent, key storage, or protection. Payment-related behavior is not described enough to establish its actual external effects. No rollback or recovery mechanism is shown. The audit and feature claims are attributable to the README, but package metadata points to a different project and repository identity and maintenance ownership are unclear, so attribution earns only limited credit.

Reliability3 / 14 · 1.1/5

The README’s architecture and run modes conflict with the package name, version, repository URL, LICENSE attribution, and the Ralph project described in CLAUDE.md. This undermines self-consistency and prevents attributing Ralph’s tests or CI to the assessed product. Docker commands and a Python version give partial dependency availability guidance, but dependencies are not pinned and source installation details are absent. The supplied test-script excerpts show error-detection logic and scenarios, but are not complete, attributable failure-handling documentation; failure-message evidence is therefore limited.

Adaptability8 / 18 · 2.2/5

The README identifies LLMs/users and lists CLI, API, Telegram, Docker, and Solana scenarios, which supports ordinary audience and scenario assessment. Tool registration and chained execution partially define capabilities, but an actual tool inventory, permission boundaries, and safety constraints are missing. Natural-language planning is described as generating plans dynamically without trigger boundaries, disambiguation, or confirmation policy. Environment guidance names Python 3.11+, Docker, and an API key, but deployment and environment-fit instructions remain incomplete.

Convention4 / 18 · 1.1/5

The README has a product overview, architecture diagram, installation steps, and Docker launch examples, but mixes project names and branches and conflicts with the supplied CLAUDE.md and package.json, so information architecture is only partially usable. The MIT LICENSE file is explicit, but package.json declares ISC; the conflicting metadata prevents full credit. There is no dependable version/change history, clear maintenance responsibility, or complete FAQ. README update dates and project links do not resolve product identity or ownership.

Effectiveness4 / 13 · 1.5/5

CLI, API, Telegram, and tool-chain output modes are described, and Docker examples make the entry points partly actionable, but there are no source-aligned usage examples or verifiable results. Natural-language planning into structured tool execution and payment-signal handling could provide value, but payment capability is described as future work or as belonging to another branch, and the materials conflict, limiting evidence of marginal value. The installation requires Docker and an OpenAI key; runtime costs, external service costs, and benefits are not explained, so cost-benefit evidence is thin.

Verifiability2 / 8 · 1.3/5

The README provides architecture, launch commands, and an audit-passed claim, while test excerpts show concrete error-detection scenarios; however, the audit report contents and attributable implementation supporting the main features and audit claim are not included. README, CLAUDE.md, package.json, and LICENSE conflict on project name, stack, repository link, and license metadata, preventing cross-source corroboration. The README partly distinguishes current features, roadmap items, and another branch’s content, but test and audit claims lack corroboration in the supplied materials, so fact/inference separation is only partial.

Risks and how to mitigate them
  • Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
  • Not found in source: disclosed external effectsEstablish which external systems it writes to, sends to or changes, and verify with test accounts or repos before production.
  • Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
  • The supplied repository materials are materially mixed: README describes Coreon-MCP/Ghost Agent, while CLAUDE.md and package.json describe Ralph, and the LICENSE conflicts with package license metadata. Do not attribute Ralph’s tests, CI, or security statements to this Agent.
  • The README claims an independent audit passed, but the report itself is not in the supplied material. Permissions, data flows, confirmation, and recovery for natural-language tool execution, API/Telegram integrations, and on-chain/payment-related capabilities are also unspecified.
Evidence confidence: Low Reviewed Nov 08, 2026 Reviewed revision 465cf43e5fa9
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/ghost-agent.svg)](https://followagents.com/en/agents/ghost-agent)
<a href="https://followagents.com/en/agents/ghost-agent"><img src="https://followagents.com/badge/ghost-agent.svg" alt="FARS review"></a>

FAQ

What credentials and costs are required?
You must supply an OpenAI API key (OPENAI_API_KEY in .env); costs for LLM calls and built-in market/news APIs are yours to bear, and some paid APIs are detected at runtime with a payment prompt.
What run modes are supported?
Three documented Docker modes: CLI, API server (port 8080), and Telegram bot, plus a Claude-style MCP stdio mode in alpha.
How is the language configured?
Set MCP_LANG to EN or ZH in .env; the README marks it as required.
How far does on-chain capability go?
Currently balance, token metadata, DeFi data, and contract-call queries on Solana; natural-language swaps, AI wallet assistants, and security monitoring are roadmap only.
Is security verified?
Yes — the Coreon MCP Execution Engine passed an independent audit by Armors Labs, with the full report published as a PDF.
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.