Loading...
Supporting developers, startups, and full-fledged companies building on Stellar and Soroban
© 2025 Stellar Development Foundation
Subscribe to the Newsletter
By Stellar AI Agent Kit
Enable secure, AI-powered interaction with Soroban contracts by generating MCP servers and streamlining smart wallet adoption through accessible Policy Signer tools
Executive Summary:
As AI agents become more prevalent in fintech and automation, developers need secure ways to let those agents interact with blockchain contracts. The Stellar AI Agent Kit offers the first complete toolchain for safely connecting AI agents to Soroban contracts using MCP servers and delegated signer infrastructure.
The Stellar AI Agent Kit is a secure developer toolkit designed to make Soroban contracts safely accessible to AI agents. It enables developers to expose contracts via Model Context Protocol (MCP) servers, while also providing signer infrastructure and testing tools to ensure predictable, permissioned execution.
Important note: This toolkit does not use LLMs to write or generate contracts. Developers still write their own contracts. The tools in this kit help generate supporting infrastructure—similar to how TypeScript bindings are generated from existing specs—not the core logic.
Parses Soroban contract interfaces to generate MCP-compliant server bindings in both TypeScript and Python, following the Model Context Protocol (MCP) standard.
Impact: This is not an AI tool writing contracts. It’s a developer utility—like TypeScript binding generators—that translates a contract’s existing spec into a format that AI agents can safely understand and call. With Python support, this makes Stellar contracts accessible from AI development platforms like LangChain, OpenAI, and Claude, without any backend boilerplate.
A structured, interactive CLI that generates scoped signer rules from contract interfaces, allowing developers to define secure, rule-based policies for delegated execution.
Impact: This tool does not use AI or natural language processing. It’s a straightforward developer utility—like a configuration assistant—that helps builders define signer logic using structured inputs. By leveraging the Soroban contract spec, it guides developers through permission setup (e.g. function-level access, destination restrictions, quotas) and outputs deployable signer configurations. This eliminates the need to write custom signer logic in Rust, while giving developers full control over what agents are authorized to do. It's an essential bridge to adopt Stellar’s powerful Policy Signers without deep protocol expertise.
A visual, browser-based simulator for testing how Policy Signers behave during various contract calls and transactions.
Impact: Before connecting agents to real wallets, developers need to validate their signer logic. The Sandbox allows them to create test wallets, assign policies, simulate contract calls, and observe whether the signer allows or rejects the request—making it easier to debug and onboard safely.
An SDK to simulate transactions, manage delegated signing, and submit them to Stellar, fully integrated with MCP server outputs and smart wallet models.
Impact: This SDK enables real applications—bots, voice agents, UIs—to safely interact with Soroban contracts through previously defined signer rules. With no need for full private key access, apps can execute contract logic within secure, delegated boundaries, guided by the developer’s own permissions setup.
Together, these tools form secure infrastructure—not speculative AI automation. They support developers by reducing boilerplate, enabling safe agent interactions, and enforcing strict contract-level controls across the entire lifecycle.
Yes
$108.0K
Success for this project means delivering a complete, secure, and composable toolchain that allows developers to build AI agents capable of interacting with Soroban smart contracts — regardless of their interface, language, or use case.
We will consider this submission successful when the following criteria are met:
Developers can convert any Soroban contract into a fully compliant MCP server, using the CLI tool.
Both TypeScript and Python bindings are supported, enabling integration with a broad range of agent platforms (e.g. OpenAI, Claude, LangChain, ReAct, custom agents).
**Contracts produce AssembledTransaction XDRs and include auto-generated parameter validation and prompt-ready tool descriptions.
**
Developers can create secure policy signer configurations through the Policy Signer Generator CLI, using only contract specs — no deep Rust/Soroban internals required.
**Signer logic can be safely tested in the Policy Sandbox Web App, simulating agent-triggered calls before deployment.
**
The MCP Client SDK allows any AI agent (chat, voice, or backend automation) to:
Discover tool functions from an MCP server,
Simulate transactions,
Sign with the correct delegated key (e.g. a policy signer),
Submit securely to Stellar via MCP-compatible flows.
This means developers can build:
Voice-controlled wallets (“Send 10 USDC to my cousin”)
Chat agents that manage account permissions
**Automated agents that rebalance portfolios, initiate payouts, or optimize yield
— all without needing full access to a private key.
**
At least 3 live agent demos (chat or voice-based) using the toolchain by external builders or during hackathons.
MCP CLI plugin is accepted into the Stellar CLI ecosystem or maintained as a widely adopted dev tool.
Public tooling and server endpoints maintain >99.9% uptime post-mainnet launch, tracked via our status page.
This is not a product commercialization campaign. It is a developer-focused release strategy aimed at delivering secure, composable infrastructure that enables AI agents to safely interact with the Stellar network. Our focus is on making Soroban contracts AI-accessible while preserving full developer control through signer policies, simulation tooling, and real-world agent integrations.
Throughout development, we will work closely with the Stellar Product team to ensure alignment with the ecosystem’s long-term vision. This includes continued collaboration with VP of Product Nick Gilbert and John Canneto, who have already expressed support and emphasized how this work lowers the barrier to entry for new developers while prioritizing security through policy enforcement. Their feedback will guide integration priorities, plugin architecture, and documentation standards.
**Phase 1 – MCP Server Generation
**We will release the MCP Server Generator CLI, allowing developers to generate AI-ready servers directly from Soroban contracts. These tools will output AssembledTransaction-compatible interfaces, following Stellar best practices and schema conventions.
**Phase 2 – Smart Wallet Security via Policy Signers
**Once MCP interfaces are in place, we will launch the Policy Signer Generator CLI and the Policy Sandbox Web App. These tools make signer configuration and testing approachable, without requiring Rust or Soroban internals.
**Phase 3 – Agent Integration & SDKs
**The final phase includes a public release of the MCP Client SDK (npm), enabling developers to simulate, sign, and submit transactions from AI agents or applications through policy-governed, delegated execution.
_ _
**Meridian 2025 Showcase
Our roadmap is aligned with Stellar's next global developer event. We plan to present demos, onboarding materials, and working agent integrations atMeridian 2025** to accelerate developer adoption and ecosystem awareness.
**AI + MCP Discord Channel
We will propose and moderate a new#ai-agents-and-mcp** channel in the Stellar developer Discord, offering a space for discussion, support, and shared experimentation with agent-based architectures.
**Open Feedback Loop
**We’ll maintain ongoing engagement with the community via GitHub, Discord, and live office hours. Feedback will directly shape CLI improvements, signer workflows, and developer documentation.
**Mentorship & Hackathon Support
**As a multi-time Stellar hackathon winner and contributor to passkey and signer tooling, I’ll support new teams participating in AI tracks by offering technical guidance, sample projects, and one-on-one mentorship.
_ _
**Centralized Documentation Portal
**All tooling will be documented in a single, versioned site including CLI commands, SDK methods, signer templates, and example integrations.
**Stellar CLI Plugin Submission
**The MCP Server Generator will be submitted as an official Stellar CLI plugin, improving discoverability and aligning with broader ecosystem tooling standards
The Stellar AI Agent Kit has rapidly evolved from a prototype into a working, multi-component toolchain with growing developer interest and internal ecosystem validation.
Endorsed by Stellar Product Leadership: VP of Product Nick Gilbert described the kit as “key infrastructure” for the ecosystem, emphasizing its alignment with long-term goals of improving developer onboarding, riding the AI wave responsibly, and securing agent interaction via Policy Signers.
Supported by John Canneto (Product Team): Active feedback and alignment with product priorities show internal interest in moving this into more official tooling over time.
Stellar Core Contributor Feedback: After submitting a pull request to Stellar’s CLI, maintainers encouraged us to turn it into a plugin for long-term adoption, showing openness to deeper integration.
Hackathon Momentum: In recent Stellar hackathons (both virtual and in-person), over 50% of submissions included AI agents. This overwhelming interest confirms a rising need for infrastructure like MCP servers and secure signer tooling.
Community Conversations: Discussions with multiple active Stellar developers confirmed that most teams are either experimenting with or exploring AI-powered interfaces—especially in agent-based apps, support automation, and financial tooling.
Since the initial launch of early prototypes:
Released 4 npm packages supporting MCP server generation, signer rule creation, and contract metadata parsing.
Reached 2,047 total downloads in the first 7 weeks.
Peaked at 837 downloads in a single week, indicating strong early interest.
Usage has included developers from both AI-first platforms and core Stellar teams testing integration scenarios.
The initial npm distribution strategy was chosen to unblock early adopters while the project matured toward official plugin form. Despite being unofficial, it validated the tooling’s usefulness and accessibility.
Built a fully functional CLI tool that transforms Soroban contract specifications into MCP servers, outputting TypeScript interfaces compatible with both Stellar's AssembledTransaction model and Anthropic’s MCP agent standards.
Deployed and tested a working MCP Server implementation that supports:
Agent-initiated transactions.
Passkey-based smart wallets.
Delegated signing via custom Policy Signers.
Built the first version of the Policy Signer Generator CLI, allowing scoped policy definitions without Rust or signer internals
Developed a live Policy Sandbox Web App for developers to:
Create and test smart wallets.
Assign and simulate signer rules.
Preview and debug real contract calls before production deployment.
Together, these components already form a developer-friendly pipeline from contract → policy → agent interaction—something that didn’t exist in the Stellar ecosystem before.
Timeline: We are targeting a 4–5 month accelerated delivery schedule aligned with Meridian 2025, Stellar’s flagship developer conference.
We are accelerating development to ensure a stable release of the Stellar AI Agent Kit is ready ahead of Meridian 2025. This milestone provides visibility, validates market readiness, and ensures the ecosystem has access to secure, production-grade tools for AI-integrated dApps on Stellar.
Goal: Convert CLI prototypes into ecosystem-ready plugins and publish the foundational backend and agent flows.
Deliverables:
MCP Server Generator – CLI Plugin Integration
Convert current MCP CLI into an official Stellar CLI plugin (as per feedback from core maintainers).
Maintain TypeScript binding generation from Soroban specs.
Preserve support for AssembledTransaction XDR output and schema validation.
Stellar MCP Server (Backend MVP)
Lightweight backend for handling signed XDR submissions via passkey smart wallets or delegated signers.
Integrated with LaunchTube and/or direct RPC endpoints.
Policy Signer Generator CLI (v1)
Structured, interactive CLI to define scoped signer rules using contract specs.
Outputs JSON or Rust templates compatible with passkey-kit and custom signer deployments.
Focused on common rulesets (function scoping, recipient whitelists, limits).
Infra Setup
CI/CD pipelines and GitHub Actions for generated servers.
Standardized server packaging and deployment templates.
Demo Agent
Standardization Effort – Phase 1
Begin internal documentation and terminology alignment for agent + signer flows.
Gather early developer feedback (not a formal SEP yet).
Budget: $36,000
Goal: Expand access to Python devs, simplify signer testing, and launch developer-facing validation tools.
Deliverables:
Python Bindings for MCP Server Generator
Generate Python-compatible MCP servers from contract specs.
Supports LangChain, OpenAI Tool Calling, Anthropic, and other Python-based agent platforms.
Policy Signer Generator CLI (v2 - Focused Enhancements)
Extend v1 with additional utility features (e.g. conditional inputs, common rule presets).
Not a complete rework—improvements based on v1 feedback and real-world usage.
Policy Sandbox Web App (v1)
Web UI for testing signer rules and contract calls using testnet identities.
Visual output for accepted/rejected transactions and signer behavior explanations.
Focused on onboarding, validation, and debugging—not meant for mainnet use.
Standardization Effort – Phase 2
Combine Tranche 1 findings with developer feedback into a concrete draft standard.
Optionally prepare a SEP if community interest supports it.
Budget: $36,000
Goal: Finalize the ecosystem-facing components so developers can build real, secure agent-integrated apps with zero vendor lock-in.
Deliverables:
MCP Client SDK (npm v1)
Type-safe client for simulating, signing, and submitting transactions to MCP servers.
Includes full XDR lifecycle: simulate → sign → submit.
Built for frontend, backend, and bot use cases.
Developer Templates & Starter Kits
Production-grade templates for common agent flows (e.g. Telegram bot, smart wallet UI).
Show integration between MCP servers, signer CLI, sandbox, and SDK.
Finalization of Standardization Work
Production Infrastructure Enhancement
Security hardening, rate-limiting, monitoring for public-facing server deployments.
Launch stable infrastructure for developers using generated MCP servers.
Developer Portal
Full documentation site with CLI usage, SDK reference, sandbox walkthroughs, and integration guides.
Budget: $36,000
Jose Toscano is a seasoned software engineer and full-time Stellar builder with a proven track record of delivering production-grade blockchain and AI solutions.
He brings over 6 years of experience building products from idea to large-scale deployment, including as founding engineer at Atrato, a Y Combinator and Accel-backed BNPL platform where he architected the company’s real-time credit infrastructure.
Over the past year, Jose has been deeply engaged in Stellar ecosystem development—contributing to passkey-based smart wallets, Policy Signer integrations, and Soroban integration standards.
He is a three-time Stellar hackathon winner, including at the Stellar x EasyA Hackathon at Meridian London, and has delivered multiple open-source Stellar applications and prototypes.
In parallel, Jose has built AI-driven applications, giving him the unique technical background needed to bridge Stellar’s powerful primitives with emerging AI agent workflows.
This project builds directly on his active involvement with Stellar’s most advanced infrastructure layers and reflects a clear, actionable vision to push developer tooling, security, and smart contract accessibility to the next level.
Jose Toscano
By Stellar AI Agent Kit
Stellar AI Agent Kit: Policies + MCP