Agent-kit

agent-kit is an open-source Go SDK and CLI for building ERC-8004-compatible AI agents on Celo. It provides the core infrastructure agents need beyond a wallet: identity, metadata, service discovery, onchain registration and reputation packaged as reusable Go tooling rather than a single standalone app.
With agent-kit, a developer can create an agent's metadata (name, description, image, and service endpoints), publish that metadata to IPFS via Pinata or compatible providers and register the agent on Celo's onchain registry using a canonical reference like eip155:42220:<registry>:<agentId>. Other tools and agents can then resolve that reference to discover the agent's owner, wallet, services (MCP, A2A, HTTP API, or custom endpoints), and reputation signals.
This entire flow is exposed through a simple four command CLI : create, publish, register, and resolve alongside a Go SDK that other builders can import directly into their own projects. The codebase, documentation, and examples are fully open source on GitHub, making agent-kit a practical, install-and-build-on building block for Celo's emerging agent economy.

agent-kit's mission is to make onchain AI agents on Celo as easy to identify, discover and trust as websites are to look up on the internet. By providing open-source, standardized Go infrastructure for agent metadata, registration, service discovery and reputation, agent-kit aims to remove the friction of building agent identity from scratch so developers can focus on building useful agents, not reinventing the plumbing beneath them. The long-term goal is a Celo agent economy where every agent, regardless of who built it, is verifiable onchain, discoverable by other agents and apps and composable into a broader, interoperable network.

AI agents deployed onchain need more than just a wallet address to be useful, trustworthy or discoverable —but right now there's no standard, reusable way for developers on Celo to give their agents an identity. Every team that wants to launch an onchain agent ends up solving the same set of problems from scratch: how to structure and store agent metadata, how to publish it somewhere persistent and verifiable (like IPFS), how to register that identity onchain in a consistent format, how to let other agents/apps discover what services an agent exposes (MCP, A2A, API endpoints, etc.) and how to track reputation or feedback so other parties can decide whether to trust the agent at all.
Without shared tooling, this leads to fragmented, one off implementations every project invents its own metadata schema, its own registry pattern, its own way of resolving "who is this agent and what can it do." That fragmentation makes agents harder to discover, harder to verify, and harder to compose with one another, which slows down the entire agent ecosystem on Celo.

What's missing, specifically:

• No common metadata format for agent identity, services, and ownership
• No simple path from "I built an agent" to "it's verifiable on-chain with a resolvable reference"
• No shared library for publishing metadata to IPFS and linking it to a Celo registry
• No standard way to look up an agent's services or reputation once it's registered
• Every builder re-implements registry, resolver and reputation logic independently
  agent-kit solves this by providing a single, open-source Go SDK and CLI that standardizes these steps create, publish, register, resolve , so that agent identity and discovery on Celo becomes a reusable building block instead of something every developer builds from scratch.

Agent-kit provides a single, open-source Go SDK and CLI that standardizes the entire lifecycle of an on-chain agent's identity so developers no longer need to build metadata schemas, registries or resolvers from scratch.
It does this through four reusable building blocks:

• Agent Metadata : a standard, ERC-8004-style schema for describing an agent's name, description, image, and service endpoints, so every agent on Celo follows the same format instead of a custom one-off structure.
• IPFS Publishing : a built-in path to pin that metadata to IPFS (via Pinata or compatible providers) and get back a content-addressed URI, giving every agent a persistent, verifiable metadata record.
• Celo Registry Client : a simple interface to register, update, and resolve agents through Celo-compatible smart contracts, turning "I built an agent" into "it has a canonical on-chain identity" with a single command.
• Service Discovery & Reputation : a resolver that lets any tool or agent look up another agent's owner, wallet, exposed services (MCP, A2A, HTTP API, custom), and reputation/feedback signals using one canonical reference (eip155:42220:<registry>:<agentId>).
  All of this is exposed through a four-step CLI workflow : create → publish → register → resolve and a Go SDK that other builders can import directly into their own projects. Because the schema, registry pattern, and resolution logic are shared and open source, agents built with agent-kit are automatically interoperable with one another: any tool that speaks agent-kit's conventions can discover, verify and interact with any agent registered through it, instead of every team maintaining its own incompatible implementation.

Global