Fetch.ai Agent Examples
Build autonomous and multi-agent Python systems from runnable reference projects.
The CI workflow uses read-only contents permission, while the PR AI review adds only pull-request write access and checks out the base branch. SECURITY.md prohibits real secrets and directs examples toward .env.example files. Calculator regression tests also cover code-execution payloads. However, the repository includes high-impact payment, email, calendar, browser-automation, and Web3 examples without per-example evidence here for least privilege, data destinations, or side-effect boundaries. A payment test sets human_input_mode to NEVER and only comments that the payment protocol supplies approval; the approval implementation is not shown. No general rollback or recovery mechanism is evidenced. README attribution and the LICENSE copyright line provide limited provenance, but publisher identity is unverified and the license statements conflict.
CI checks changed Python files, validates repository structure, and invokes example tests. The supplied payment tests cover parsing, empty input, timeout errors, and adapter construction, while calculator tests cover hazardous input and explicit error messages. Deductions reflect that these tests cover only a small fraction of the large collection, dependencies are not shown as locked or hash-pinned, and no compatibility matrix or availability fallback is evidenced. Broad claims that every folder is runnable and production-ready are not adequately supported. The README/LICENSE conflict also weakens self-consistency.
The README clearly identifies beginners, builders, hackathon participants, and contributors, then organizes examples by scenario, stack, and difficulty; audience and scenario handling is thorough. Python 3.10+, virtual environments, Docker, Compose, environment variables, and multiple model/framework integrations provide reasonable environment fit. Deductions apply because capability limits, selection conditions, and unsuitable use cases are thin, while repository-level rules governing when autonomous agents may trigger payments, browsing, or messaging are absent.
The index, repository tree, categories, quickstart, Docker guidance, contribution flow, resources, and FAQ form a strong information architecture. Installation notes are sufficient for one starter but are not shown to work uniformly across all examples. Naming is inconsistent in capitalization, spaces, and style, including Rag-agent, Crewai-agents, and Claude Agent SDK. Known limitations are largely confined to prerequisites and a brief third-party terms warning. Most importantly, the README, badge, and structure description repeatedly say Apache 2.0 while the supplied LICENSE and metadata are MIT, so the license criterion receives zero. Only a community changelog is identified, and neither a repository-wide release history nor a specific accountable maintenance channel is established.
The broad set of use-case starters, navigable documentation, Docker path, contribution template, and localized safety/error tests plausibly reduce the effort required to begin many agent prototypes, supporting high marginal value and good output usability. Deductions apply because the claims of 80+ production-ready, two-minute startup, and universal self-contained runnability are not demonstrated item by item. Many examples rely on paid or externally operated APIs, yet pricing, rate limits, operational burden, and the benefit-risk tradeoff for consequential actions receive little treatment.
The README maps many capability claims to concrete directories, and CI plus the two supplied test areas make some architecture, safety, and error-handling claims traceable. The evidence nevertheless examines only two examples in depth and cannot corroborate the whole 80+ collection. Tests and code provide limited local cross-support but no independent corroboration. Promotional claims are not clearly separated from demonstrated facts, particularly production readiness, universal runnability, and the unresolved license assertion.
- The README repeatedly states Apache 2.0, while the LICENSE text and supplied license metadata are MIT; maintainers must resolve this before use, redistribution, or commercial deployment.
- Do not treat “production-ready” or universal folder runnability as verified. This assessment executed nothing, and detailed tests were supplied for only a small subset.
- The payment executor test shows human_input_mode set to NEVER. Do not connect real funds until the payment protocol's verifiable human approval, amount limits, and rejection path are confirmed.
- Email, calendar, browser, payment, and Web3 examples may create external effects. Review permissions, data transfers, credential scope, logging, and recovery separately for each example before deployment.
- Evidence for dependency locking, comprehensive supply-chain checks, and third-party API cost controls is insufficient for production reliance.
What does this agent do, and when should you use it?
This repository is a collection of more than 80 independent Python agent projects rather than one deployable agent product. Each example is generally self-contained, with its own README, dependencies, and environment template, while uAgents supplies messaging, discovery, or payment capabilities across many projects. The collection spans ASI:One, Agentverse, MCP, A2A, LangChain, CrewAI, Gemini, Claude, OpenAI, RAG, browser automation, and payment integrations. Outputs vary by example and include structured vulnerability reports, interactive news cards, PDF summaries, route maps, PDF and Excel files, and other task-specific results. Projects can run in local Python environments, through the repository-level Docker configuration, or—where documented—on Agentverse, Render, or ASI Cloud. It is best suited to developers seeking reference implementations and prototype foundations, with each chosen example requiring a separate review of credentials, providers, maturity, and tests.
A developer selects a self-contained example, installs its requirements.txt, and configures the credentials listed in its .env.example, which may include ASI:One, OpenAI, Anthropic, Google, Stripe, or another vendor. The documented starter launches with python agents/alice/agent.py, while ./setup.sh fetch-hackathon-quickstarter provides repository-level setup automation. Depending on the project, uAgents handles agent messaging, discovery, and payments while integrations call ASI:One, the OpenAI Agents SDK, Anthropic SDK, Google Gemini, LangChain, CrewAI, AG2, Pydantic AI, LlamaIndex, MCP servers, or the A2A protocol. Concrete workflows fetch and summarize news, track flights, scan code for vulnerabilities, search vector stores, summarize PDFs, automate browsers, coordinate research teams, and process Stripe, FET, or Skyfire payments. A repository-level Dockerfile builds a selected project through the EXAMPLE argument, Docker Compose can run it, and several examples supply additional container configurations.
- A Python developer new to Fetch.ai can begin with fetch-hackathon-quickstarter to study the orchestrator-and-worker pattern.
- A hackathon team that needs a working prototype quickly can adapt a self-contained project with documented dependencies and environment variables.
- A platform engineer evaluating agent communication can compare independent A2A connections with in-process orchestration through CrewAI, AG2, or Google ADK.
- An application developer integrating external services can consult examples for MCP, Gmail, Calendar, GitHub, Stripe, Google Maps, Duffel, or browser automation.
- A knowledge-product team can prototype vector retrieval, document question answering, or PDF summarization with Rag-agent, llama-index, and pdf-summariser-example.
- A community contributor can package a new project under contributors/<your-agent-name>/ using the supplied agent README template and contribution process.
What are this agent's strengths and limitations?
- More than 80 self-contained projects cover beginner templates and advanced A2A, MCP, RAG, payment, and multi-agent patterns.
- The collection demonstrates multiple provider and framework paths, including ASI:One, OpenAI, Claude, Gemini, LangChain, CrewAI, AG2, Google ADK, and Pydantic AI.
- Repository-level setup, Docker, and Docker Compose paths reduce the work needed to start a selected example locally or in a container.
- Examples address concrete tasks and produce inspectable artifacts such as vulnerability reports, news cards, PDF summaries, maps, PDFs, and spreadsheets.
- The index identifies each project's stack and difficulty, making it easier to choose an entry point appropriate to the developer's experience.
- This is a heterogeneous example collection, not a single product with one API, configuration model, entry point, or operational contract; adopters must integrate and maintain their chosen pieces.
- Most examples require at least one API key, and some depend on separately priced OpenAI, Anthropic, Google, Stripe, mapping, news, or other vendor services.
- Advanced projects combine several frameworks, payment systems, or external APIs, increasing deployment and troubleshooting costs.
- The supplied material does not provide repository-wide benchmarks, security validation, reliability guarantees, or production service-level evidence for the production-ready claim.
- License information conflicts: the supplied repository metadata says MIT, while the README badge, repository tree, FAQ, and license section say Apache 2.0; adopters must inspect the actual LICENSE file.
How do you install or deploy this agent?
Prerequisites are Python 3.10+, pip, and git. Run:
git clone https://github.com/fetchai/innovation-lab-examples.git
cd innovation-lab-examples
cd fetch-hackathon-quickstarter
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .envEdit .env and add the API keys required by that example. As an alternative, run ./setup.sh fetch-hackathon-quickstarter from the repository root. Dependencies and credentials are not uniform across the collection, so inspect the selected project's README and .env.example.
How do you use this agent?
After configuring the quickstarter, run this inside fetch-hackathon-quickstarter:
python agents/alice/agent.pyFor a containerized launch from the repository root, run:
docker build --build-arg EXAMPLE=fetch-hackathon-quickstarter -t fetch-example .
docker run --env-file fetch-hackathon-quickstarter/.env fetch-exampleDocker Compose is also documented:
EXAMPLE=fetch-hackathon-quickstarter docker compose upFor another project, replace the directory and EXAMPLE value and supply every credential listed in that project's .env.example.
How does this agent compare with similar options?
The repository explicitly illustrates two multi-agent approaches. A2A connects independent agents over a shared protocol, as shown by a2a-uAgents-Integration, while CrewAI, AG2, and Google ADK orchestrate teams within one process. It also includes separate OpenAI, Claude, Gemini, and ASI:One integrations, but the source does not establish feature parity or drop-in interchangeability among them.