Cardano’s Mesmo Brings AI-Assisted Development to Python, Go, Rust, and JavaScript

Cardano Foundation Senior Software Architect Mateusz Czeladka provided a technical walkthrough of Mesmo during the 84th Developers Office Hours session, hosted by Fabian Bormann. The presentation explored how the open-source library makes Cardano development functionality accessible across multiple programming languages, with particular attention to transaction processing, AI-assisted development, and integration with blockchain infrastructure.

The discussion went beyond Mesmo's existing language support to examine how its architecture works, what developers can build with it, and which technical limitations remain in the version presented.

Mesmo Uses a Shared Execution Engine for Cardano Transactions

Mesmo is built around Cardano Client Lib, a Java software development library whose functionality is compiled into a native shared library using GraalVM Native Image. Language-specific wrappers allow applications written in Python, Go, Rust, and JavaScript to access that compiled code through a standard C Application Binary Interface (ABI).

This architecture allows developers to use supported Cardano operations without running a Java Virtual Machine. It also provides access to functionality that may be missing from an application's primary software development kit.

Czeladka explained that the approach emerged partly from differences in maintenance schedules across Cardano libraries. During the discussion, participants recalled an earlier period when the Go-based Apollo library lacked Plutus V3 transaction support, requiring architectural adjustments in applications that depended on it.

Rather than replacing established tools such as MeshJS, PyCardano, Pallas, or Apollo, Mesmo provides access to selected functions from a shared implementation.

Its capabilities include wallet and address management, transaction signing, staking operations, native scripts, and Cardano governance transactions. The governance functionality extends to specialized operations involving Constitutional Committee voting and other actions beyond standard DRep delegation.

A central component is TX Plan, which describes transactions through structured YAML data. Instead of constructing each operation through a sequence of language-specific methods, developers provide a transaction definition that Mesmo interprets and processes.

This model allows applications written in different languages to access the same underlying transaction logic while retaining control over their surrounding infrastructure.

AI Coding Agents Can Work With Structured Cardano Transactions

One area explored during the presentation was Mesmo's compatibility with AI-assisted software development.

The project provides an AI starter pack containing information about its programming interfaces. Developers can supply these materials to AI coding tools to help them understand available functions, expected inputs, and supported transaction operations.

TX Plan offers a structured interface for this workflow. An AI coding agent can generate a YAML transaction definition, which an application can pass to Mesmo for transaction construction.

The distinction between generating a transaction and executing it on the blockchain remains important.

Mesmo does not independently connect to Cardano nodes, retrieve on-chain information, or broadcast transactions. Those responsibilities belong to the application integrating the library.

For example, an application can obtain available UTXOs and protocol parameters from a supported blockchain data provider, pass those inputs to Mesmo, and receive serialized transaction data. After signing, the application submits the transaction through its chosen network service.

Czeladka described the underlying execution as deterministic and stateless, meaning the same supplied inputs produce the same results without the library independently changing external blockchain state.

The presentation also examined offline Plutus evaluation. Mesmo includes an embedded Scalus evaluator that can calculate the memory and CPU execution units required by supported smart contract transactions. Developers can integrate alternative evaluators through the available interface.

This arrangement allows transaction construction and script evaluation to take place locally, without requiring a separate network request for the evaluation itself.

Account handling follows a similar separation of responsibilities. An account object can retain the necessary key material for address generation and transaction signing, avoiding repeated transmission of mnemonic phrases between application functions.

However, the use of native libraries introduces memory-management considerations. Participants discussed how resources should be released across the boundary between the host programming language and native code, particularly when sensitive cryptographic material is involved.

[NEWSBREAK]

Pre-Release Constraints and Potential WebAssembly Support

The presentation identified several practical limitations in Mesmo's implementation.

JavaScript support in the version demonstrated relies on the Bun runtime. Node.js is not supported because of difficulties involving its Foreign Function Interface.

Another constraint is the compiled library's size, approximately 60 MB. Czeladka described this as a potential trade-off for server-side applications and a more substantial obstacle for environments with strict package-size requirements.

Native distribution also requires compatible builds for different operating systems and processor architectures. Supporting those combinations adds maintenance work as the project expands.

Czeladka discussed WebAssembly as a possible future alternative. GraalVM's developing WebAssembly capabilities could eventually provide a more portable execution target, reducing the need to distribute separate native binaries across multiple platforms. The presentation did not establish a release date or confirm production availability for that approach.

Other development possibilities include additional integrations with blockchain data providers, language-specific transaction builders, improved error handling, and broader support for signing and contract-related metadata.

The implementation presented uses TX Plan as its primary transaction-construction interface. More conventional programming methods could be developed on top of the shared engine if community demand supports that work.

Mesmo also includes architecture decision records and open-source documentation intended to help contributors understand and extend the implementation.

The team is seeking feedback from developers testing the available language wrappers and transaction functions. Contributions can include new blockchain data providers, improvements to resource management, and support for missing operations.

In the implementation demonstrated during Developers Office Hours, Mesmo provides transaction construction, signing, and local Plutus evaluation through its shared native library, while applications remain responsible for network access and submitting completed transactions.