FastAgent
A Python-first CLI and framework for building, running, and evaluating MCP-enabled agent workflows.
- Source repo
- evalstate/fast-agent
- Stars
- ★ 3.9k
- Last updated
- 1d ago
- License
- Apache-2.0
- Primary language
- Python
- FA score
- 46/100 · Major gaps
At a glance
- Works with
- Universal · cross-platformCodex · OpenAI API · Claude API
- You'll need
- Typical use
- A Python developer who needs to chain MCP-enabled agents that summarize a URL and turn the result into a social-media post.
- Main limitation
- It requires Python and uv, while the supplied material does not state a Python version, provider credential setup, or complete production deployment requirements.
- Source review
- 46/100 · Major gaps 1 safety controls not found
What does this agent do, and when should you use it?
FastAgent is a CLI-first Python framework and interactive tool for coding, development tooling, evaluations, and workflow applications. Developers define agents and workflows with the FastAgent class and decorators such as @fast.agent, @fast.chain, and @fast.parallel, then execute them inside fast.run(). It connects to stdio, SSE, and Streamable HTTP MCP servers, and an application can also run in MCP server mode. The project includes an optional prompt_toolkit terminal interface, Rich-based streaming terminal output, Shell Mode, and commands for skills and MCP connections. Its documented model support includes Anthropic, OpenAI, Google, Azure, Ollama, Deepseek, and additional providers through TensorZero; FastAgent applications can also be used with ACP clients.
Users can run fast-agent go for an interactive session, use /skills to manage skills, use /connect to attach MCP servers, and issue shell commands with !, including commands such as ! cd web && npm run build. In Python, an application creates FastAgent, registers agents with @fast.agent using instruction, servers, model, human_input, and function tools, then calls them with agent(...), .send(), .prompt(), or .interactive() inside async with fast.run(). It supplies chain sequencing, parallel fan-out/fan-in, evaluator_optimizer refinement loops, router selection, orchestrator planning, maker K-voting, and child agents exposed as tools. A program can be exposed in MCP server mode with uv run agent.py --transport http --port 8001; HTTP and SSE MCP connections can use OAuth with PKCE, a local callback, and keyring-backed secret storage.
- A Python developer who needs to chain MCP-enabled agents that summarize a URL and turn the result into a social-media post.
- A developer using an OpenAI Codex plan or Hugging Face Inference Providers who wants to start a coding session through --pack codex or --pack hf-dev.
- A team that needs to fan out translation, research, or multi-model tasks and combine results through a fan-in agent.
- An engineer who wants to expose a custom agent.py application over HTTP as an MCP server for another MCP client.
- An integrator connecting to authenticated remote HTTP or SSE MCP servers that require OAuth and PKCE.
- An application developer who needs evaluator_optimizer refinement or MAKER repeated sampling and voting for selected outputs.
How do you install or deploy this agent?
Install uv first, then run:
uv pip install fast-agent-mcp
fast-agent goAlternatively, install it as a uv tool:
uv tool install -U fast-agent-mcp
fast-agent --model opus -x --smartThe supplied material does not document the exact environment variables or configuration needed for individual model-provider credentials. Those provider-specific credentials must be configured before using the selected provider. No Python version requirement is stated.
How do you use this agent?
For a quick interactive session, run:
uvx fast-agent-mcp@latest -xInside the session, use /skills, /connect @modelcontextprotocol/server-everything, or /connect https://huggingface.co/mcp. To start a project, run fast-agent scaffold and then uv run agent.py. To expose it as an MCP server, run:
uv run agent.py --transport http --port 8001The minimal Python pattern is to create FastAgent, define an agent with @fast.agent, then call await agent("message") inside async with fast.run() as agent.
What are this agent's strengths and limitations?
- It documents both MCP client connectivity and MCP server mode, including stdio, SSE, and Streamable HTTP transports.
- It offers concrete, composable workflow primitives: chains, parallel runs, routing, orchestration, evaluator-optimizer loops, MAKER, and child agents as tools.
- It has documented paths for Anthropic, OpenAI, Google, Azure, Ollama, Deepseek, local/generic models, and more providers through TensorZero.
- Its interactive CLI combines skill management, MCP connection commands, Shell Mode, completions, and in-terminal menus for development work.
- Its remote MCP OAuth flow documents PKCE, callback handling, an in-memory fallback, and keyring token storage.
- It requires Python and uv, while the supplied material does not state a Python version, provider credential setup, or complete production deployment requirements.
- Model access, remote MCP services, and OAuth flows commonly require network connectivity, and model-provider capabilities are not identical.
- MCP tool-result content is constrained by provider APIs: OpenAI supports text only, Anthropic supports text and images, and Google additionally supports PDFs and video.
- When keyring is unavailable, OAuth token storage falls back to memory for the session, which may not suit headless deployments requiring persistent authentication.
- The README notes extra Windows configuration for Filesystem and Docker MCP servers, but the supplied material does not provide those changes.
How does this agent compare with similar options?
The project states that it builds on Sarmad Qadri's mcp-agent project. It also says its Agents As Tools workflow is inspired by the similarly named OpenAI Agents SDK feature; the supplied material does not provide a feature-by-feature comparison or migration guide.
Key facts side by side with the most closely related agents.
| Agent | Source review | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|
| FastAgent This agent | 46 · Major gaps | ★ 3.9k | 1d ago | Python | Codex · OpenAI API · Claude API |
| Dexto | 51 · Major gaps | ★ 651 | 1d ago | TypeScript | Claude Code · OpenAI API · Claude API |
| Microsoft Learn MCP Server | 43 · Major gaps | ★ 1.9k | 13d ago | TypeScript | ChatGPT · Codex · Claude Code · Claude.ai |
| Compartment | 76 · Good | ★ 582 | 1d ago | Python | Codex · Claude Code |
How does FollowAgents rate this agent?
Why each dimension lost points
Evidence: README mentions OAuth with PKCE and in-memory token storage, not written to disk by default; keyring option for token persistence; MCP server configuration requires explicit user definition. However, no detailed documentation or implementation for least privilege, user confirmation, data flow transparency, sensitive data handling, dependency security, external effects, rollback, or source attribution. Deductions: lack of explicit least-privilege policy, user confirmation mechanism, data flow transparency, sensitive data handling details, dependency security audit, external effects control, rollback mechanism, and source attribution verification.
Evidence: README and pyproject.toml provide consistent installation and usage instructions; CI workflow (checks.yml) runs unit and integration tests. However, no dependency availability guarantees (e.g., lock files, mirrors) or detailed failure message design. Deductions: dependencies are pinned but no lock file; failure messages not documented.
Evidence: README describes multiple use cases (coding agent, dev toolkit, evaluation platform), supports multiple model providers and MCP servers; provides rich configuration options (model, servers, workflows). However, capability boundaries and trigger precision are not clearly defined. Deductions: capability boundaries not explicit; trigger precision (e.g., command triggers) not detailed.
Evidence: README is well-structured with installation, usage, examples; LICENSE file (Apache-2.0); pyproject.toml defines version and entry points. However, no known limitations, changelog, or maintenance responsibility. Deductions: missing known limitations, changelog, maintenance responsibility.
Evidence: README provides extensive examples and usage; output format (e.g., --quiet switch) suitable for automation; multiple workflows (chain, parallel, evaluator-optimizer) add value. However, no cost-benefit analysis. Deductions: cost-benefit not quantified.
Evidence: Claims in README (e.g., MCP feature support) are supported by tests and CI; but no external source verification or separation of facts and inferences. Deductions: lack of external source corroboration; facts and inferences not clearly separated.
- Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
- Unverified publisher identity: Publisher not verified in FollowAgents curated enterprise registry; identity unknown.
- Dependency security: Dependencies are pinned but no lock file provided, and no security audit.
- Least privilege: No explicit least-privilege policy; may grant excessive permissions by default.
- Rollback: No rollback mechanism; may not recover from failed updates.
- Known limitations: No known limitations listed; users may encounter unexpected issues.