Aser: A Modular Python Agent Framework with Web3 and Multi-Protocol Support

What Aser Is and What Problem It Targets

Aser targets developers who find existing Python agent frameworks too heavy or too opinionated. The README describes it as minimalist, modular, and versatile: the intent is that you can assemble an agent with a handful of lines of code, plug in only the integrations you need, and avoid pulling in a large dependency graph for features you are not using.

The simplest Aser agent requires only a name and a model identifier:

from aser.agent import Agent
agent=Agent(name="aser agent",model="gpt-4.1-mini")
response=agent.chat("what's bitcoin?")
print(response)

A fully configured agent adds tools, a knowledge store, a memory backend, social platform connectors, MCP servers, and a tracer in a single Agent constructor call. The framework is built around this single entry point. There is no separate initialization phase or context manager; all components are passed at construction time.

The target audience covers a range from beginner developers building their first agent to intermediate developers implementing multi-agent workflows, RAG pipelines, or blockchain-enabled agents. The README organizes its examples into beginner, intermediate, and advanced sections to reflect that range.

Core Architecture: Agent, Tools, Memory, and Knowledge

Aser's Agent class accepts a modular list of optional components. Tools are Python callables that the agent can invoke to fulfill requests. The framework ships built-in toolkits (available via Boxcars::Toolkits-style bundles in agent_toolkits.py) and supports defining custom tools through agent_tools.py examples.

Memory is handled through a pluggable backend. The pyproject.toml lists both TinyDB and Supabase as dependencies, covering local file-based storage and cloud-hosted persistence. Knowledge retrieval uses ChromaDB for vector storage, enabling RAG workflows where the agent searches a document corpus before answering.

Chain of Thought reasoning is available as a configuration option through the agent_cot.py example. The MCP (Model Context Protocol) integration allows connecting MCP servers to the agent, extending its tool set with any MCP-compatible service. The full configuration example from the README shows all these options assembled together:

aser = Agent(
    name="aser",
    model="gpt-4o-mini",
    tools=[web3bio, exa],
    knowledge=knowledge,
    memory=memory,
    chat2web3=[connector],
    mcp=[price],
    trace=trace
)

The trace parameter connects an observability backend for monitoring agent decisions. The chat2web3 parameter is specific to Aser: it accepts connectors to Web3 blockchain infrastructure, reflecting the framework's origin in the AmeNetwork ecosystem.

Installing Aser and Running a First Agent

Aser requires Python 3.13.2 or newer. The simplest installation path uses pip:

pip install aser

Alternatively, you can clone the repository and install from source:

git clone https://github.com/AmeNetwork/aser.git
cd aser
pip install -r requirements.txt

If you install from a source clone and want to run the examples in the examples/ directory, the README specifies running pip install -e . in the root directory first so Python can locate the aser module from the local source.

Before running any agent, create a .env file based on .env.example. At a minimum you need the model base URL and API key:

MODEL_BASE_URL=<your model base url>
MODEL_KEY=<your model key>

The .env.example file lists additional variables for each integration: SUPABASE_URL and SUPABASE_KEY for Supabase memory, TELEGRAM_BOT_TOKEN for Telegram, DISCORD_BOT_TOKEN for Discord, COINMARKETCAP_API_KEY for market data toolkits, and EVM_PRIVATE_KEY for blockchain transactions. You configure only the variables for the integrations you actually use.

Multi-Agent Patterns and Protocol Integrations

Aser implements five multi-agent topologies, each with a dedicated example file: router (tasks distributed to agents based on routing rules), sequential (agents work one after another in a pipeline), parallel (agents run simultaneously), reactive (agents respond to events or state changes), and hierarchical (agents at different levels of authority). These patterns are composable: a hierarchical arrangement can include a sequential sub-chain at one level.

Beyond the standard multi-agent patterns, Aser includes two protocol integrations that distinguish it from most Python agent frameworks. The A2A integration (based on Google's Agent2Agent protocol) provides server and client components: agent_a2a_server.py and agent_a2a_client.py. This enables Aser agents to communicate with other A2A-compatible agents regardless of the underlying framework.

The MSCP (Model Smart Contract Protocol) integration ties agent actions to EVM-compatible blockchains. The ERC8004 connector handles on-chain identity registration for agents, a design aimed at use cases where agents need verifiable on-chain identities. This is an experimental integration: the README lists ERC8004 examples under an Experiments section rather than with the production-ready patterns.

The self-coding tool example in the advanced section is also experimental: the agent generates new Python tool code and executes it. The README lists this as an advanced capability without extensive documentation.

Social Platform Clients and the Dependency Footprint

Aser's requirements.txt and pyproject.toml list dependencies for eight social platforms: Discord (discord-py-interactions), Telegram (python-telegram-bot), Twitter/X (tweepy), Mastodon (Mastodon.py), Bluesky (atproto), Farcaster (atproto with farcaster mnemonic), and a general web3 connection (web3). All eight platform clients are installed as part of the base package.

This is a notable design choice. Frameworks that aim for a minimal base install typically make these dependencies optional, requiring developers to add only what they use. Aser installs all of them regardless. On a fresh install, pip resolves dependencies for Discord, Telegram, Twitter, Mastodon, Bluesky, ChromaDB, Supabase, FastAPI, and web3 simultaneously. The total dependency footprint is substantial.

For developers who only need a basic conversational agent without social media or blockchain connectivity, the full install pulls in packages they will never use. This is a meaningful trade-off between setup simplicity (one install covers everything) and environment cleanliness. The framework does not currently document a minimal install path that omits the optional platform clients.

Aser vs. LangChain and Similar Python Agent Frameworks

LangChain is the most widely used Python framework for LLM-powered applications and the most direct point of comparison. LangChain provides a more extensive set of integrations, a larger community, and more detailed documentation at the cost of a more complex API surface and a heavier base install. Aser's Agent constructor is a single Python class with keyword arguments; LangChain separates chains, agents, tools, and memory into distinct abstractions that must be assembled following its own patterns.

For teams already on LangChain with existing chains and tools, Aser offers no migration path. The two frameworks are not compatible at the code level. Aser is a better choice for developers starting a new project who prefer a smaller surface area and who specifically need the Web3, MSCP, or ERC8004 integrations that LangChain does not provide. The A2A protocol support is also notable: LangChain does not include a built-in A2A client-server implementation.

The lack of a Python version below 3.13.2 is a practical constraint. LangChain supports Python 3.9 and newer. Teams on older Python versions cannot use Aser without upgrading their environment.

Editorial conclusion

Aser is a practical fit for developers who want a minimal Python starting point for single-agent or multi-agent systems, especially if their use case touches Web3 blockchains, social platform clients, or the A2A agent interoperability protocol. It is less suitable for teams that need a production-ready, audited framework with extensive documentation: the README links to external docs at docs.ame.network, and the last push was on 2026-04-21. The Python 3.13.2 minimum is a strict requirement. Verify that your chosen social or blockchain integration is covered by the environment variables in .env.example before building on top of it.

Frequently asked questions

Official sources

1. AmeNetwork/aser on GitHub
2. Issues
3. License: MIT
4. Project website
5. README