Brian

Brian is an intent recognition and execution engine for Web3 that converts plain-text prompts into executable on-chain actions. Rather than navigating protocol interfaces, connecting wallets to individual dApps, and manually configuring transaction parameters, users and AI agents can describe what they want in natural language — and Brian handles the translation into signed-ready transactions, protocol answers, or deployable smart contract code.

The project positions itself at the intersection of two trends it sees as defining the next phase of blockchain: the rise of autonomous AI agents as on-chain actors, and the shift toward intent-based interfaces that abstract away the complexity of transaction construction. Brian's core thesis, stated in its documentation, is that "most of the on-chain transactions would be either performed by autonomous AI Agents or users via intent-based apps" in the coming years — and that existing infrastructure was not built to serve either use case well.

How It Works

Brian's architecture divides into two discrete components that operate in sequence.

The Intent Recognition Engine receives a text prompt and uses Brian's domain-specific AI models to extract structured parameters from it. A prompt like "swap 10 USDC for ETH on Arbitrum" is parsed to identify the action type, input token, output token, amount, and target chain. The engine is built around models trained on a proprietary dataset of Web3 intents — covering transaction instructions, protocol Q&A, and Solidity code patterns — rather than relying on general-purpose language models that lack deep domain specificity.

The Intent Execution Engine takes those structured parameters and builds the actual output. For transactions, this means querying off-chain tools and on-chain aggregators to assemble valid, optimal transaction data. For information requests, it retrieves and synthesizes protocol documentation. For smart contract generation, it produces Solidity code ready for review and deployment.

Brian operates in a non-custodial manner throughout. The platform never holds private keys or funds. It assembles the transaction and returns it to the user's interface for final review and signing — meaning users retain full custody and confirm every action before it hits the chain.

Supported Chains and Operations

Brian supports a broad range of networks. On the EVM side: Ethereum, Arbitrum, Optimism, Base, Polygon, zkSync Era, Blast, Scroll, Gnosis, Taiko, Mode, Linea, and BNB Chain. Beyond EVM, Brian also supports Starknet and Solana.

Solana support was added in December 2024, with Jupiter as the primary solver for swaps and transfers. Solana transactions are returned in serialized format compatible with Solana-Web3.js, requiring deserialization, signing, and execution — a flow similar to working directly with Jupiter's API. This makes Brian a practical tool for building Solana-native agents or intent interfaces without having to integrate routing and aggregation infrastructure from scratch.

Supported operation types span the main DeFi categories:

• Swaps and bridges: single-chain swaps and cross-chain bridges via aggregators including LiFi, Enso Finance, Bungee Exchange, Avnu.fi, Symbiosis, and Jupiter (for Solana)
• DeFi deposits and withdrawals: Aave v3 (including borrowing, repayment, and loan-to-value checks), Lido, Frax, Rocket Pool, Compound, and Portals
• Transfers: token transfers on all supported chains
• ENS domains: registration and renewal
• Smart contract generation: ERC-20 and Solidity contract code from text prompts

Amounts can be expressed numerically, in USD equivalents, or as percentages of a balance — for example, "withdraw 25% of my Aave USDC position."

AI Models

Brian develops and maintains its own Web3-specific language models rather than prompting general-purpose models through system instructions. The current production model, Brian-Llama-3.2-3B, is built on Meta's Llama 3.2 3B base and fine-tuned on Brian's proprietary Web3 instruction dataset. An earlier iteration, Brian-8B (built on Llama 3.1 8B), is available as open weights on Hugging Face for teams wanting to self-host or further fine-tune.

The rationale for domain-specific models over general-purpose alternatives is lower inference cost, better accuracy on Web3-specific intents, and the ability for external developers to run or adapt the model for their own applications.

Developer API and SDKs

The Brian API exposes five primary endpoints:

• /transaction — generates executable transaction data from a natural language prompt
• /knowledge — returns textual answers with sources for protocol and market questions
• /agent — combines transaction generation and text response in a single call, designed for chat-based agent interfaces
• /smart-contract — generates Solidity code from a text description
• /parameters-extraction — extracts structured intent parameters without executing anything, useful for building custom execution layers on top of Brian's recognition engine

A TypeScript SDK supports custodial, non-custodial, and smart account implementations. A LangChain integration allows developers to equip LangChain-based agents with the ability to execute on-chain transactions and deploy tokens — connecting Brian's Web3 intent layer to the broader AI agent tooling ecosystem.

Projects built using Brian's API and SDK include Mode's DeFAI Copilot, the AskBrian Farcaster bot, Segugio (a copy-trading system via XMTP messaging), Ava (a DeFi portfolio management agent), and Briannah (an ERC-20 deployment tool operating on Farcaster).

Background and Development History

Brian originated at ETHPrague and was developed iteratively through hackathon participation and public build logs. The project ran a private beta in November 2023, launched its production API in May 2024, and has shipped a structured series of updates since: Scroll and ENS support (May 2024), Blast and Aave v3 (June 2024), multi-solver support including Avnu.fi and Starknet (August 2024), the /agent endpoint (October 2024), and Solana support via Jupiter (December 2024).

In early 2025 the team launched a Prompt-to-Earn rewards program inside the Brian App, distributing Brian points to users who submit prompts and execute transactions through the interface. Pre-allocations were made available for early users and API developers.

Fit Within the Solana Ecosystem

Brian's Solana integration is primarily relevant to developers building agentic or intent-based applications on Solana — teams that need to handle token swaps, transfers, and DeFi interactions without building their own routing and aggregation infrastructure. By routing Solana transactions through Jupiter, Brian connects its natural language layer to the deepest liquidity aggregation available on the network. For projects building AI-native DeFi interfaces or autonomous on-chain agents, Brian provides a ready-made intent layer that handles the translation between user commands and valid Solana transactions.