uAgents
Build Python autonomous agents that join the Fetch.ai agent network.
- Source repo
- fetchai/uAgents
- Stars
- ★ 1.6k
- Last updated
- today
- License
- Apache-2.0
- Primary language
- Python
- FA score
- 45/100 · Major gaps
At a glance
- Works with
- Platform-specific
- You'll need
- Typical use
- A Python developer needs a local task that runs every two seconds and records its result through the
Contextlogger. - Main limitation
- Network participation depends on Almanac on the Fetch.ai blockchain, so the operating model is tied to that ecosystem.
- Source review
- 45/100 · Major gaps 2 safety controls not found
What does this agent do, and when should you use it?
uAgents is a Fetch.ai Python library for autonomous programs that run scheduled work or react to events. Developers define agents and execution logic with `Agent`, `Context`, and decorators such as `@alice.on_interval(period=2.0)`. At startup, each agent registers with Almanac, a smart contract deployed on the Fetch.ai blockchain, and joins the uAgents network. The project states that agent messages and wallets are cryptographically secured to protect identities and assets. A minimal application runs as a local Python script and can emit log output, while `python/uagents-core` provides core definitions and functionality for software integrating with the Fetch.ai ecosystem and agent marketplace.
Application code creates an agent with Agent(name="alice"); it may supply a seed, including seed=os.getenv("ALICE_SEED_PHRASE"), to establish a fixed address. Without a seed, the private key is stored locally alongside the agent name in private_keys.json; without a name, a new address is generated on every run. Developers register asynchronous work with @alice.on_interval(period=2.0), for example async def say_hello(ctx: Context), and emit output through ctx.logger.info(...). Calling alice.run() runs the registered scheduled or event-driven actions and registers the agent with Almanac at startup.
- A Python developer needs a local task that runs every two seconds and records its result through the
Contextlogger. - A team deploying an agent with a stable identity wants to pass a recovery phrase to
Agentthrough theALICE_SEED_PHRASEenvironment variable. - An application developer wants a Python agent to join the uAgents network and register with Fetch.ai Almanac when it starts.
- A Fetch.ai ecosystem project needs agent identities and wallets described as cryptographically protected.
- A developer building software that interacts with the Fetch.ai ecosystem and agent marketplace needs the core definitions and functionality in
uagents-core.
How do you install or deploy this agent?
Use Python 3.10 through 3.13. Install from a shell with pip install uagents. After installation, save the example application as a local agent.py file and run it with python agent.py. The example imports Agent and Context from uagents, then starts the defined agent by calling alice.run() in its main entry point.
How do you use this agent?
Create agent.py with from uagents import Agent, Context, then define alice = Agent(name="alice", seed="alice recovery phrase"). Decorate an async function with @alice.on_interval(period=2.0) and call alice.run() in the main entry point; run it with python agent.py. Supply a seed for a fixed address; the example also supports reading it from ALICE_SEED_PHRASE.
What are this agent's strengths and limitations?
- It exposes a direct Python interface built around
Agent,Context, and decorators; the minimal example registers a periodic async task. - Startup registration with Almanac connects agents to the uAgents network, which suits applications needing the documented Fetch.ai network boundary.
- The repository documents cryptographic protection for messages and wallets, plus seed-based stable addresses.
uagents-corespecifically supplies core definitions and functionality for Fetch.ai ecosystem and agent-marketplace integration.
- Network participation depends on Almanac on the Fetch.ai blockchain, so the operating model is tied to that ecosystem.
- The supplied material explicitly supports only Python 3.10 through 3.13; it provides no support evidence for other versions.
- When no seed is supplied, private keys are written locally to
private_keys.json, so deployers must protect and retain that file. - The supplied material does not document hosted deployment, pricing, transaction costs, or model-provider configuration.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|
| uAgents This agent | 45 · Major gaps | ★ 1.6k | today | Python | — |
| Sprix SAGE Router | 69 · Some gaps | ★ 3.8k | 26d ago | Python | — |
| Hello-Agents | 54 · Major gaps | ★ 81k | 1d ago | Python | OpenAI API |
| Generative AI with LangChain | 52 · Major gaps | ★ 1.4k | 1mo ago | Jupyter Notebook | OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
Evidence shows: README mentions private keys stored locally in private_keys.json, but no least-privilege or user confirmation mechanisms; data flow transparency only mentions encryption of messages and wallets, not detailed data flows; sensitive data handling only mentions encryption, not key management details; dependency security has CI tests and Ruff, but no vulnerability scanning evidence; external effects: agents auto-register to Almanac contract, but no user confirmation or revocation mechanism; rollback not mentioned; source attribution clear with Fetch.ai and Apache license. Deductions: lack of user confirmation, insufficient data flow transparency, insufficient dependency security evidence, external effects lack user control.
Evidence shows: README and example code consistent, CI config covers multiple Python versions and OSes, indicating some consistency; dependency availability has CI tests, but no lock file or mirror info; failure messages: examples have logging, but no error handling docs. Deductions: insufficient dependency availability evidence, failure message handling not detailed.
Evidence shows: README clearly targets developers, provides multiple scenario examples (multi-agent, local network interaction); capability boundaries defined via decorators (on_interval, on_message); trigger precision shown via interval and message triggers; environment fit supports Python 3.10-3.13 and multiple OSes. Deductions: capability boundaries not well documented, limitations not detailed.
Evidence shows: README well-structured with quickstart, docs links, examples, contributing guide; install notes clear (pip install uagents); naming stability: version badge but no changelog; examples and FAQ: example code and docs links, but no separate FAQ; known limitations not listed; license Apache-2.0 with full text; versioning/changelog not provided; maintenance responsibility via contributing guide and issue tracker. Deductions: missing changelog and known limitations.
Evidence shows: output usability: example code runnable, rich docs links; marginal value: unique features (auto-register to Almanac); cost-benefit: open-source free, but no performance or resource data. Deductions: lack of performance data, marginal value based on features not empirical.
Evidence shows: README claims (security, connectivity) partially supported (encryption, registration), but no detailed technical docs; cross-source verification: official docs links, but no independent verification; fact-inference separation: README distinguishes features and disclaimer, but not explicitly labeled. Deductions: claims lack detailed evidence, cross-source verification insufficient.
- 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: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
- Agents auto-register to Almanac contract, which may have external effects; users should be aware and control this.
- Private keys stored locally in private_keys.json; ensure file permissions are secure.
- Dependency security lacks vulnerability scanning evidence; check dependencies before use.
FAQ
Is a recovery phrase required?
seed establishes a fixed address. Without it, the private key is stored locally in private_keys.json alongside the agent name; omitting the name produces a new address each run.Does it need network access?
Can it run locally?
agent.py and runs it with python agent.py.