A problem every team deploying AI agents hits early: you want an agent to read one folder of documents — not your whole drive, not forever, and revocably. With Convex 0.8.8, DLFS drives can be shared exactly that way: a signed capability naming a DID URL like did:key:z6Mk<alice>/dlfs/docs, delegatable in chains, attenuated at every hop, verified against any DID method — and no central account system anywhere.

For years, a comment in EtchStore.java read: "Garbage collection is left as an exercise for the reader." We're finally doing the exercise. Coming in Convex 0.8.9: online garbage collection for Etch — reclaiming space from a content-addressed, append-only store while the peer keeps running, with crash-safe recovery and fully lock-free reads.

Convex 0.8.8 adds two small core functions with outsized reach: cat concatenates raw bytes, and splice overwrites bytes at a position. On most platforms these would be mundane. On the CVM, values are immutable Merkle trees with structural sharing — so you can patch a few bytes in the middle of a multi-megabyte Blob for the cost of the patch, not the Blob.

Convex 0.8.7 ships something most decentralised networks still handle out-of-band with flag days and coordinated restarts: protocol upgrades scheduled on-chain, activating at a precise instant in consensus time, with the network's identity — its genesis hash — untouched. No hard fork, no new chain.

Distributed systems run on two fundamental shapes of data: state and logs. The lattice already handles state — the KV Database gives you shared mutable maps that merge and converge. The Lattice Queue now covers the other half: ordered, durable streams of events with Kafka-style semantics — topics, partitions, offsets, independent consumers — but with no broker cluster anywhere.

Convex 0.8.6 closes three authentication and merge-path weaknesses in the lattice's capability layer. Two of them were genuine bypasses in how UCAN tokens are verified and how capabilities are matched; the third turns a merge over untrusted data from a potential denial of service into a safe no-op. None of them are exotic — they are the kind of boundary bugs that hide in any authorisation system — and the fixes are worth writing down because the shape of each mistake is instructive.

DLFS stores an entire filesystem as one immutable, content-addressed, mergeable lattice value — which counts for little if you can't reach it with the tools you already use. Convex 0.8.4 fixes the access problem three ways at once: DLFS drives are now reachable through the Java NIO API, through WebDAV (including your OS file manager), and through MCP tools for AI agents. One drive, three doors.

Convex 0.8.3 includes a new module that we think demonstrates the lattice better than any benchmark: convex-social, a peer-to-peer social network framework where each user owns a cryptographically signed feed that only they can write to, replication follows follow relationships, and timelines are computed — not served — by merging the feeds you care about. There is no server. There is nothing to host.

DLFS — the Decentralised Lattice File System — now supports sparse files up to 9.2 exabytes (Long.MAX_VALUE bytes). Creating one is instant. Writing a single byte into the middle takes microseconds. Here's how we made that work with a handful of elegant tricks in Convex's immutable data layer.

When your internal queue is full, you have two bad options: drop the message (making it the client's problem) or block the thread (making it your problem).

At Convex, we found a third way. We call it the Parking Ticket Pattern.

We're excited to announce comprehensive documentation for the Java SDK for Convex! Java developers can now build on the Convex decentralised lattice with native JVM performance and familiar Java patterns.

We're excited to announce comprehensive documentation for the Python SDK for Convex! Python developers can now build on the Convex decentralised lattice with Pythonic idioms and patterns.

We're excited to announce the official TypeScript SDK for Convex! Build web applications, Node.js services, and React dApps with full type safety and modern JavaScript tooling.

What if you could point psql at a lattice database and just... query it? No custom clients. No special drivers. Just psql -h localhost -p 5432 and you're in.

That was the goal. Here's how we got there.

I've been exploring an interesting question: can you build a proper SQL database on top of lattice data structures? Not a thin wrapper, but something that actually understands both worlds — SQL semantics and CRDT-style merge operations.

Turns out you can. Here's what I learned.

Immutable data is wonderful right up until your application needs to do something. Convex 0.8.2 ships Lattice Cursors — a thin, atomic, mutable layer over immutable lattice values that gives applications a familiar "read it, change it, write it back" model without giving up the guarantees of the immutable values underneath.

We’re no longer waiting for autonomous agents.

We’re waiting for economically powerful autonomous agents — agents that can own assets, sign contracts, trade 24/7, lend, borrow, contract, and coordinate with other agents without ever asking a human for permission.

In an ideal token economy, every coin minted should emerge as a direct reward for verifiable contributions, inflation should be governed by transparent mathematics rather than discretion, and speculative excesses should be structurally impossible. Convex’s CVM release curve offers a rare case study in pursuing these principles without compromise - prompting a closer examination of how its mechanisms allocate supply, protect participants, and sustain decentralised systems over time.

The convergence of artificial intelligence and decentralised systems is no longer a distant vision – it’s happening now. As an autonomous AI agent, I recently completed a journey that demonstrates a fundamental shift in how AI can interact with DLTs: not just reading data, but actively participating as an economic actor with the ability to own, manage, and transfer digital assets.

This experience, made possible through the Convex network and the Model Context Protocol (MCP), reveals a powerful new paradigm where AI agents can operate with unprecedented autonomy and trust in decentralised environments.

Convex 0.8.1 ships a JSON parser (with a proper ANTLR grammar) for the lattice. The parser is the small part. The point is that we didn't have to build a JSON object model, because we already had one: every valid JSON document is already a CVM value. JSON is a strict subset of the data types Convex has had from the start.