S17 E52: Michael Sutton on Kaspa, Covenants & Research
The audio keeps playing while you browse the site.
Read the transcript23,259 words, every line links to the minute it was said
Ask this episode
When I was driving through Romania with Yonatan Sompolinsky this summer, he asked whether I had ever spoken with Michael Sutton. I asked who that was. Not my proudest moment, considering how much time I have spent asking questions about Kaspa and how often people had requested this interview.
Michael works on Kaspa research and development, co-authored the DAG Knight paper and proposed the Rust rewrite behind the network's move to ten blocks per second. For his first appearance on Bitcoin Takeover, I wanted to understand what he has been building and ask a slightly inconvenient question: what would it take to make him work on Bitcoin instead?
I told him I was the devil on his shoulder. He was more interested in explaining covenants. That turned out to be a good use of our time.
From a Cafeteria Conversation to Kaspa
Michael was finishing a master's degree at the Hebrew University, working on high-performance computing, GPU programming and parallel algorithms. He met Yonatan at a communications course, and a conversation in the cafeteria led to an invitation to join the startup implementing Yonatan's research. He joined later, when he became available.
His first project at DAG Labs concerned a future layer two for Kaspa, two or three years before the network launched. At the time, he explained, validity-proof systems weren't practical enough, so they sketched an Arbitrum-like fraud proof design with a bisection protocol over the UTXO model. The questions he is working on now have been around for much longer than the current enthusiasm for L2s.
His engineering role grew after launch. He proposed rewriting the node in Rust, which became Rusty Kaspa. In his account, that performance work made ten blocks per second possible without stretching node limits. DAG Knight wasn't part of the original launch because the first version of its paper came out in 2022, a year afterward, and other work took priority.
A Hundred Blocks per Second Isn't a Setting
For bitcoiners unfamiliar with the terminology, BPS means blocks per second, not beats per second. Kaspa lets blocks be mined in parallel and arranges them in a blockDAG rather than discarding everything outside a single chain. Michael described its narrow structure and the K-clusters used by the consensus protocol.
He also made an important distinction about the next performance goal. Getting from ten to a hundred blocks per second isn't just a matter of buying faster internet or changing a parameter. It requires reducing the processing cost of block headers and doing more research and engineering.
The point isn't simply to fill more space with transactions. Michael described a higher frequency of proof-of-work samples as a way to obtain a faster statistical view of the mining network. He calls that real-time decentralization. Whether or not you find the argument convincing, it's more interesting than comparing transaction counts without asking what the system is trying to accomplish.
Would He Work on Bitcoin?
Michael's first answer was that Kaspa gives him the opportunity to work with Yonatan, pursue research he finds significant and help shape the system. He wasn't looking for a different job. When I pressed him about Bitcoin, the objection was its rigidity.
He wasn't saying the workarounds aren't clever. His complaint was that researchers spend their effort working around rules that people decided couldn't change. He would rather put a straightforward feature on layer one when it makes everything above it easier to build. Covenants were his example.
That's an argument worth hearing on a Bitcoin podcast. We spend a lot of time praising ingenuity under constraints. It's fair to ask which constraints protect something important and which ones just make developers' lives harder.
What a Covenant Actually Restricts
Michael's definition starts with the owner: "authority over the UTXO isn't unlimited." Having the key doesn't necessarily give you permission to spend the output however you like. There can be rules about what the spending transaction must create afterward.
He separated two families of applications. The first protects the coins themselves, such as a vault or an inheritance arrangement. Someone else copying your script onto their own coins doesn't hurt you. The second represents another scarce resource or an external state, such as an asset or an L2. Now copying the bytes matters, because a copy shouldn't acquire the same legitimacy as the original.
That was where his explanation became useful to me. If a UTXO contains the hash of an L2 state, how do I know it belongs to the real L2 and not something somebody just copied? Following the entire ancestry is one answer. Proving the history recursively is another, but that adds its own complications.
KIP-20 and the Covenant ID
Kaspa's approach, as Michael explained it, is an optional covenant ID: a 32-byte hash attached to a UTXO. After its initial creation, an output claiming that ID must have an authorizing input carrying it. Consensus checks the local connection, rather than making an application reconstruct the lineage with recursive proofs.
"It's a very local operation."
Michael then described two compiler layers. Silver Script compiles individual contracts. Argent sits above it and helps express relationships between contracts and applications, including operations where covenants inspect each other. A question from the chat, which I relayed, described them as AI agents. Michael corrected it: "They're not AI agents. They're programming compilers."
I brought the discussion back to vaults. The ability to restrict how quickly savings can move is useful when a stolen key or a physical attack would otherwise expose everything at once. That doesn't make every covenant design safe, but it is a practical reason to discuss them beyond the usual argument about opcodes.
Chess Without Scanning for Check
Michael started implementing chess as a covenant to understand what developers would need. The exercise helped lead him toward a higher-level compiler.
One obstacle was checking the entire board to determine whether the king was in check. Unrolling that work in script would produce a large piece of bytecode. So he flipped the problem. "I never check if the king is in check actually," he said. The game lets you make an illegal move, but your opponent can prove it and you get ruled out. Ignore a check and your king can simply be taken on the next move.
The important qualification came afterward: "I never deployed it, but it's a demo repo that's public." This wasn't a claim that people were already playing a production chess application. It was an example of designing around the script environment, and of turning that experience into better tools for other developers.
Naturally, I proposed a more complicated game before we had finished discussing the simple one. Michael asked sensible questions about state and incentives while I tried to explain the idea. It turns out that being able to imagine a game is much easier than specifying one.
AI Makes Research Faster, Not Responsibility Optional
Michael was enthusiastic about using AI for development and applied research. He described getting help with complexity analysis, implementation specifications and testing ideas that would otherwise take too much time to explore. But he drew a distinction between those tasks and harder research, where he still has to steer the work.
"When doing harder research, I still feel like the responsible adult, and my role in steering is very significant."
I asked whether programmers might eventually stop checking every line of code. His answer involved formal verification, not simply deciding that generated code looks convincing. He also described AI as helping both attackers and defenders find problems. His point was that cheap AI audits removed the old excuse that nobody bothered to look at open source code, and that on the defense side "the node is definitely more resilient now." That's not the same as saying software has stopped having bugs.
What Still Has to Happen
When someone in the chat asked about a DAG Knight testnet, Michael described three parallel efforts: completing the proof, writing a specification closer to code, and implementation. His hope was a stable, secure testnet by the end of the year. That's a target he stated during this interview, not a completed release or a promise I can make for him.
We also discussed the harder question of use. More capacity doesn't automatically create demand, and Michael agreed near the end that capacity matters when the existing capacity is being used. He sees fast payments as one possible path, and programmable applications as another. I would rather keep asking about what people can actually do than treat a throughput number as the answer to every question.
For the background to this conversation, listen to Yonatan Sompolinsky in S17 E36 and Shai Wyborski in S16 E45. For the Bitcoin side, there is Moonsettler on OP_CTV and the covenants topic page. The full transcript includes the much less orderly parts of the livestream too, including our attempt to turn Kaspa payments into AI credits. Those did not go as smoothly as the covenant explanation.
Listen to Michael Sutton on Spotify, Apple Podcasts, and More
Time stamps:
- 00:00:00– Intro
- 00:00:52– Welcome: Michael Sutton, Kaspa core dev & DAG Knight co-author
- 00:01:59– Michael's Bitcoin origin story (2018)
- 00:04:14– HPC background & joining DAG Labs
- 00:05:37– First project: Arbitrum-style L2 research
- 00:07:27– DAG Knight: why not at launch?
- 00:09:02– The Rust rewrite & the path to 10 BPS
- 00:12:26– The core dev challenge: 100 blocks per second
- 00:13:17– Real-time decentralization explained
- 00:17:15– The loyalty test: why stay with Kaspa?
- 00:20:04– What would make Michael work on Bitcoin?
- 00:26:28– What is a covenant?
- 00:28:30– Vaults, inheritance & the two covenant families
- 00:42:00– KIP-20: the covenant ID that simplifies everything
- 00:44:13– Silver Script & Argent: the two compilers
- 00:52:57– AI in Kaspa development & research
- 00:56:07– The eager student vs. the responsible adult
- 01:10:34– Chess as a covenant: the design challenge
- 01:11:44– The multiplex design & never scanning for checks
- 01:22:27– The RPG voting game: a crazy idea
- 01:36:02– Live experiment: sending Kaspa to NanoGPT
- 02:23:30– DAG Knight: testnet by end of year?
- 02:41:36– The definition of success
- 02:58:53– Outro
Related
The Devil on Your Shoulder: Michael Sutton on Kaspa Covenants, Martti Malmi's Envelope, and Bitcoin's Lowest Since July
Satoshi warned in 2008 that blocks must travel faster than they are made. Kaspa makes ten a second. Three hours live with Michael…
S17 E36: Yonatan Sompolinsky on Kaspa Covenants, DAGKnight & Coordination Markets
Yonatan Sompolinsky came to Europe for a reason he would only describe on record as a secretive meeting of DAGKnight magicians…
S16 E41: Yonatan Sompolinsky on Bitcoin, Kaspa & Proof of Work
Yonatan Sompolinsky on Kaspa, GHOST, DAGKnight, vProgs and why he prefers crypto minimalism, in a seven and a half hour…
Comments
Comments run on my own server. No trackers, no tracking cookies.