Agentor Agent Framework

Build and deploy durable Python agents, MCP tools, and agent-to-agent services.

Stars
★ 210
Last updated
1mo ago
License
Apache-2.0
Primary language
Python

At a glance

How it runs
Library / SDKSelf-hosted serviceMCP server
Works with
Universal · cross-platformOpenAI APIClaude API (Partial support)
Cost
Free software; you pay for model usage
Setup effort
Low · running in minutes
You'll need
PythonLLM provider API keyCELESTO_API_KEY (only for tracing)Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
Python developers connecting tools such as weather lookup to a model and serving the agent over HTTP.
Not a fit if
  • Teams that need to use a model without supplying an API key
  • Debugging teams that expect tracing to be enabled by default

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

Agentor is a Python framework for creating agents with the `Agentor` class and invoking models and tools through `run`. Agents can connect tools, load configuration from Markdown, and expose an ASGI API through `serve()`. With a `FileStore`, runs are persisted as append-only event logs and can be resumed or forked. The project also includes LiteMCP for building MCP servers and A2A interfaces for agent communication. Model requests go to the configured provider; tracing is off by default and can be viewed in Celesto’s observability interface when enabled.

After installing agentor, create an Agentor in Python with a name, model, and tools, then submit work with run() or chat(); the agent can call its configured tools and return a result. agent.serve() exposes it as an ASGI service with a /chat endpoint and automatically enables A2A-compatible endpoints. Configure a FileStore to persist runs, then use resume() to continue an interrupted run or fork() to create a separate run. Developers can also define and serve MCP tools using LiteMCP and @mcp.tool.

  1. Python developers connecting tools such as weather lookup to a model and serving the agent over HTTP.
  2. Teams that need to resume agent runs after interruption or branch new tasks from prior runs.
  3. Engineering teams exposing existing agents through standard endpoints for other agents to call.
  4. Developers integrating custom MCP tools into a FastAPI application or running a standalone MCP server.
  5. Teams configuring an agent’s name, tools, model, and temperature in Markdown before loading it.

How do you install or deploy this agent?

A Python environment is required. Install the base package with the command below; optional extras are available for Google tools or all optional tools.

How do you use this agent?

Set the API key required by your chosen model provider and create an agent with Agentor. This example calls a weather tool and starts the service, which exposes /chat. Tracing requires CELESTO_API_KEY and is off by default.

What are this agent's strengths and limitations?

Pros
  • Connects to OpenAI-compatible /chat/completions providers using base_url and api_key.
  • FileStore supports persisted runs, resuming interrupted runs, and forking existing runs.
  • agent.serve() exposes an ASGI service with A2A-compatible endpoints.
  • LiteMCP can integrate with FastAPI as a native ASGI app or run as a standalone MCP server.
Limitations
  • Running a model requires the relevant provider API key; the README does not describe a no-cost local model path.
  • Tracing must be enabled separately and requires CELESTO_API_KEY; traces may include prompts, tool arguments, results, and model reasoning.
  • Tools for Google, GitHub, Slack, and other integrations require optional extras.
  • The README does not specify the full supported Python version range or provider feature differences.

How does this agent compare with similar options?

The README compares LiteMCP with FastMCP: it describes LiteMCP as a native ASGI app that integrates with FastAPI using standard patterns and includes built-in CORS, while FastMCP requires mounting as a sub-application. This is the project’s stated comparison.

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

Agent Source review Form / cost Stars Updated Language Full support on
Agentor Agent Framework This agent 50 · Major gaps Library / SDKFree + model costs ★ 210 1mo ago Python OpenAI API
Osaurus 80 · Good Desktop appFree + model costs ★ 8k today Swift OpenAI API · Claude API
LycheeMemory 52 · Major gaps CLIFree + model costs ★ 1.1k 2mo ago Python Claude Code · OpenAI API
AgentPool Orchestration Hub 44 · Major gaps CLIFree + model costs ★ 192 5mo ago Python Codex · Claude Code · OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
50/ 100 5-point scale 2.5 / 5
Trust 12/29
Reliability 6/14
Adaptability 10/18
Convention 11/18
Effectiveness 7/13
Verifiability 4/8
Why each dimension lost points
Trust12 / 29 · 2.1/5

The README says tracing is off by default; when enabled, it includes prompts, tool arguments, tool results, and provider-returned reasoning, and can be disabled per run. This supports limited data-flow transparency (2). However, the API-key example reads from an environment variable, the authentication example relies on users checking a token themselves, and no global permission model, sensitive-data protection, or user confirmation for destructive tools is shown, so least privilege, confirmation, sensitive-data handling, and control of external effects score 1. Persistent event logs support resume and fork (rollback 2), but deletion, recovery failures, and compensation for external side effects are not explained. Dependencies have lower bounds and optional extras (1), but there is no evidence of locking, auditing, or vulnerability mitigation. LICENSE, author metadata, and a vulnerability-reporting process provide limited attribution; the publisher is unverified and no clear maintainer commitment is given (source_attribution 1).

Reliability6 / 14 · 2.1/5

The README describes durable runs, resume, fork, and sync/async interfaces; the test workflow covers three operating systems and Python 3.11–3.13, showing some engineering support (1, 2). However, the README describes the v0.1.0 line while the test's expected agent card contains version 0.0.1, an inconsistency between documentation and test expectations that lowers self-consistency. Comments say missing optional dependencies produce a clear ImportError, but there is little evidence of failure paths or user-facing error examples, so failure_messages scores 1.

Adaptability10 / 18 · 2.8/5

The developer-facing documentation covers simple agents, ASGI serving, MCP, A2A, skills, durable runs, and several LLM endpoints, showing multiple scenarios and environments (audience_and_scenarios 2, environment_fit 2). But safety and capability boundaries are mostly feature claims; tool permission rules and suitable or unsuitable use cases are not clearly defined. Triggering is illustrated through explicit Python calls, a serve entry point, and per-run tracing options (trigger_precision 2), but boundaries for automatic triggers and side-effecting tools are not explained.

Convention11 / 18 · 3.1/5

The README is organized by installation, features, and examples; pyproject provides package metadata, a minimum Python version, and dependency extras, with reasonably clear optional-dependency installation instructions (information_architecture 2, install_notes 2). Agentor naming is stable at repository level, but the product description, package version line, and default agent-card version in tests do not fully align (naming_stability 1). Examples cover several features, and the security policy specifies reporting and supported versions; no FAQ is shown (examples_and_faq 2). The policy says older tags are unsupported and response targets are non-binding (known_limitations 2). The Apache-2.0 text is complete and consistent with metadata (license 3). There is a tagged release workflow and dynamic version source, but no changelog is provided (versioning_changelog 1). The security policy describes a small team, best-effort handling, and a private vulnerability-reporting path (maintenance_responsibility 2), but identity is not verified by the enterprise registry and there is no binding maintenance commitment.

Effectiveness7 / 13 · 2.7/5

The examples provide practical starting points for a weather agent, serving requests, durable runs, Markdown-defined agents, MCP, and A2A (output_usability 2). Durable runs, tool search, MCP integration, and A2A suggest value beyond basic model calls (marginal_value 2), but key superiority claims such as “fastest” and “secure” lack comparison methods or quantitative evidence; the core dependency set is substantial and cost-benefit discussion is limited (cost_benefit 1).

Verifiability4 / 8 · 2.5/5

Some README features correspond to configuration, CI workflows, and tests; for example, tests cover the A2A card and import timing, but this does not establish that features were executed or achieved their advertised results (claim_traceability 1). README, pyproject, LICENSE, security policy, and workflows provide limited corroboration about installation, licensing, publishing, and reporting, but the core product features have little test corroboration (1). The documentation presents code examples, feature descriptions, and claims such as “fastest” and “only” as distinguishable kinds of content, allowing visible facts to be separated from unverified performance or safety inferences (2).

Risks and how to mitigate them
  • Tracing includes prompts, tool inputs and outputs, and reasoning that a provider may return; confirm these data may be sent to Celesto before enabling it.
  • Agent tools may cause external side effects; the supplied material does not show a unified permission or confirmation flow.
  • The README and test fixture disagree on the agent-card version; do not infer the actual release version or maintenance status from that fixture.
Evidence confidence: Low Reviewed Oct 09, 2026 Reviewed revision 56f4ab6901d6
See the full review method →

FAQ

Does using Agentor cost money?
The README identifies the software as Apache 2.0 licensed; using a model requires a provider, and the README does not state model API costs.
Where are runs stored?
With FileStore("runs"), run events are written to the specified directory. The README does not describe a default persistent store or other storage backends.
Does tracing send data automatically?
No. Tracing is off by default. Enabling it requires CELESTO_API_KEY; traces can contain prompts, tool arguments, tool results, and reasoning returned by the provider.
Which model providers can I use?
The README shows Gemini and Anthropic examples, as well as providers accessed through the OpenAI-compatible interface. It does not detail feature compatibility for each provider.
Which endpoints does the service expose?
agent.serve() starts the service; the README shows /chat and says it automatically provides A2A messaging, streaming, task-management endpoints, and an agent card.
View on GitHub ↗ Install ↓

Compare agents like this one

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

Related agents