A growing share of new smart contracts are being written with the help of large language models—and that trend is not going to reverse anytime soon. The question every contract platform now has to answer is a simple one: when an AI writes a mission-critical contract for your blockchain application, can you rely on it to be correct? Are LLMs well prepared to write smart contracts safely?
Kontor's new smart contract framework, Sigil, is ideally situated for the agentic coding era for two reasons:
- Rust is, by a meaningful margin, the best language for AI-assisted coding.
- Sigil is designed so that writing a contract feels like writing ordinary Rust.
AIs will have an easier time one-shotting solutions with Sigil, especially with large and complex smart contracts, which Sigil supports better than anything else out there.
Rust Is the Language AI Codes Best In
Over the past year, a remarkable consensus has emerged among developers working seriously with AI coding tools: Rust is unusually well-suited to LLM-assisted development. Pieces such as The Compiler Does What Code Review Shouldn't Have To, Second State's Rewrite in Rust with Claude Code, Rust: The Unlikely Engine of the Vibe Coding Era all arrive at the same conclusion from different angles.
Rust's compiler refuses to let bad code through. Most languages let a confident-sounding model produce confident-looking code that runs, looks fine, and then fails on an edge case in production. Rust does the opposite: if it compiles, it is approximately correct, and if it does not, the compiler's diagnostics are detailed enough that the model can usually fix its own mistake on the next pass. This turns a coding session with an AI into a tight, self-correcting loop instead of a slow drift toward a plausible-but-broken result.
There is also a quieter reason that matters at least as much. AI models learn from what they read, and they have read enormous amounts of Rust. Rust has been one of the most popular languages on GitHub for years and the most-loved language on the Stack Overflow Developer Survey for nearly a decade running. The body of Rust code, documentation, tutorials, and Q&A that an LLM trains on is vastly larger than the body of Solidity—still widely assumed to be the natural target for AI in this space—and dwarfs the body of Move and every Bitcoin-metaprotocol DSL combined. More training material plus a stricter compiler is exactly the combination one wants when an AI is writing code that will hold real money.
Sigil Feels Like Rust—To Humans and Models Alike
Sigil's design goal is that writing a contract should feel like writing ordinary software. A Sigil contract is just a Rust module: structs, methods, `Result`, `?`, `match`, ordinary error handling. The framework is a thin, well-typed layer—not a new language, not a new mental model, and not a new set of idioms the developer has to learn.
For human developers, that translates into a beautifully gentle learning curve. For AI, it translates into something even more valuable: the model's existing Rust ability transfers wholesale. Every pattern an LLM has absorbed from years of reading public Rust code—how to structure a module, how to design with the type system, how to thread errors through a call stack, how to write tests—works inside a Sigil contract with essentially no adaptation. The model is not asked to imagine code in a niche contract DSL it has barely seen; it is asked to write Rust, which is what it is already best at.
This is the leverage point. Solidity-trained models have to draw on a smaller and noisier corpus. Move-trained models have to draw on an even smaller corpus *and* navigate idioms (`acquires`, ability annotations, two incompatible dialects) that appear nowhere else. Sigil-trained models—every model trained on the public internet, in effect—are asked to do exactly what they already do best.
On top of that, Sigil quietly closes off the patterns LLMs are most prone to misuse. Contract interfaces are typed end-to-end, so a model cannot construct a call to another contract that fails to match its signature—the compiler catches the mismatch before deployment. Storage is structured and typed rather than addressed by hand-built string keys, so the typos and silent serialization mismatches that LLMs reliably introduce simply cannot exist. And there is no `delegatecall`-equivalent, so an entire family of proxy-storage exploits cannot be expressed.
Bonus: the Testing Feedback Loop
The single most important property of a contract framework, in the age of agentic coding, is the speed of the feedback loop. Autonomous agents converge on correct code by writing, compiling, testing, reading the failures, and trying again. The faster that loop runs, the more iterations the agent gets to spend on edge cases instead of basic correctness, and the better the final contract.
Sigil's testing story is built around exactly that loop. Contracts can be tested as ordinary Rust against an in-memory backend, using the same `cargo test` workflow any Rust developer already knows. You don't need to spin up a Bitcoin node or an indexer. Hundreds of tests run per second on a laptop. The same contract code that runs on-chain runs in tests with the in-memory backend—because the runtime primitives are abstracted behind traits, the two environments are interchangeable. (Of course you can run all your tests against a local regtest instance if you want!)
For an AI agent, this is transformational. Generate, run `cargo check`, read the structured `rustc` diagnostic, fix, run `cargo test`, read the assertion failure, fix again—all in seconds, with no infrastructure between the model and the answer. It is the latency profile autonomous coding tools were designed around, and it is the latency profile contract development has historically been furthest from. Sigil collapses that gap.
Conclusion
The properties that determine whether AI-assisted contract development goes well—a language the models already know, a compiler that talks back clearly when they get it wrong, a framework that refuses to let the worst mistakes ship, and a test loop fast enough for the model to iterate productively—are the properties Sigil was built around. No other contract platform comes close.
