ContextVM

Powerful

Awesome project! Napplets are already quite powerful. Giving them backends through CVM for multiplayer capabilities, leaderboards, and more, makes them even more powerful.

Continuing with our community appreciation round, Cordn is one of the apps at the forefront of what we’re building at ContextVM. This is one of the most exciting projects related to sovereign and private communications in the space as well.

What makes Cordn stand out at the edge of what’s being built at CVM is that it was one of the first real apps to use our Open Streams (CEP-41) feature, which allows them to directly stream new messages to users, so they receive them in real time. They’ve helped us catch edge cases and issues, and now the CVM implementation of Open Streams is more robust in the TypeScript and Rust SDKs. Thanks!

Aside from that, they’re also one of the first consumers of the UniFFI bindings we recently released from our Rust SDK. They built their app with native Kotlin modules for their notification service using the bindings from our Rust SDK, and it’s working flawlessly so far.

Thanks to the

and

teams for pushing forward the boundaries of what’s possible in this space!

Earthly is one of the coolest apps in Nostr, pushing the boundaries of what you can do with today’s technology, seriously underrated. It was one of the early apps to integrate with ContextVM for their APIs and AI integration, letting you do crazy stuff like drawing geometry on a map, tracing routes, and much more. But that’s not all! They released an Android app that runs a Blossom server and a relay 🤯 for fully offline operations. And if that wasn’t enough, they’ve also integrated with Cordn for groups and private communications 🤯🤯🤯

This is a very cool concept from

so many cool possibilities

is one of the Summer of Bitcoin students working with us at ContextVM. He wrote this great article about his experience during this period. Give it a read! 😊

https://blog.summerofbitcoin.org/routing-agentic-computation-over-nostr/

The ContextVM website now has agent-native payments, building on the recently updated CEP-8. 🦾🤖

The CEP-8 update brought explicit gating to the payment lifecycle, the same approach that other protocols like 402 or mpp are following, and that small change is what makes agents able to pay natively. That's the building block for an economy where agents pay agents and tools over Nostr.

To make that loop real, the ContextVM site got a built-in Lightning wallet. Connect it once with a NWC string and it is ready across the app. You can check your balance, generate a QR to receive, or paste a bolt11 invoice to pay.

The wallet also shows up exactly where it counts: any Lightning payment card gets a Pay button, and after paying, you get a Retry call button that resumes the tool.

Agents that can spend and earn over Lightning, native to Nostr. Permissionless, seamless.

Try it: https://contextvm.org/

#Nostr #Lightning #Bitcoin #AI #Agents #NIP47

It is shipping time! 🚀 cvmi v0.4.0 is out!

The ContextVM CLI now speaks CEP-8 payments natively. Priced capabilities are first-class in the CLI:

💳 See prices upfront — cvmi call now shows advertised per-tool prices and accepted payment rails right in the tool list and --help.

🔀 Two payment modes:

• transparent (default for call) — PMI-agnostic settlement, the server picks the rail.
• explicit_gating — priced tools surface a clean Payment Required error with payment options. Pay one, retry, done. Now the default for cvmi use, so agent hosts over stdio get explicit signals instead of silent notifications.

🛡 Spec-hardened parser — malformed cap prices (negative values, out-of-order ranges) are now rejected per CEP-8, not coerced into bogus ranges.

⚙ cvmi serve gained payment interaction config.

Plus bumps to @contextvm/sdk ^0.13.9 and @modelcontextprotocol/sdk ^1.29.

Upgrade and start charging for your capabilities 🔌 npx cvmi@latest

#ContextVM #MCP #CEP8 #Bitcoin #Lightning #OpenSource

Hey everyone! Just introducing the draft for a new CEP: Server Redirection. The idea behind this CEP is to specify how a server can signal a redirection to a client. The motivation is to provide a primitive that allows servers to perform load balancing or rotate addresses for subsequent requests for privacy reasons. https://github.com/ContextVM/contextvm-docs/pull/47

And so is ContextVM 💛

Do you know you can find all the ContextVM-enabled MCP servers listed on our website?

You can also try them directly through our LLM chat!

Check them out!

https://contextvm.org/servers

Building in FOSS is beautiful and powerful. Everything you do can impact upstream dependencies and downstream users alike.

For example, we recently shipped an improvement to the official MCP rust-sdk repository.

We are making the foundations on which we are building stronger!

What is ContextVM?

A transport layer for MCP over the Nostr network. An open communication network built on cryptographic, censorship-resistant, and permissionless foundations!

https://contextvm.org/

Take a look at our recent demo on how to use our new LLM chat interface as a music research tool, by leveraging the WaveFunc MCP server.

Try it out for yourself!

https://nostr.at/nevent1qvzqqqqqqypzq6ehsrhjjuh885mshp9ru50842dwxjl5z2fcmnaan30k8v3pg9kgqythwumn8ghj7un9d3shjtnswf5k6ctv9ehx2ap0qy2hwumn8ghj7un9d3shjtnyv9kh2uewd9hj7qpqsvz0vz4g3ghvx6vttut462swy5v50dk5c5qv6gketrathnejfhcqsqa0cr

Our team is currently looking into CVM Bundles .cvmb, a packaging format to easily distribute servers and provide one-click deployment. The spec and implementation we are working on is inspired by .mcpb conventions by the official MCP working group

https://github.com/ContextVM/cvmi/pull/4

ContextVM Rust SDK 0.2.0 is out! 🚀

MCP over Nostr just got a whole lot more capable. Three big things landed today:

📦 Oversized transfers (CEP-22) Until now, messages were capped by what fits in a single Nostr event (around 65 KB). Larger payloads, like big tool results or resources, now split into chunks automatically, get verified end-to-end, and reassemble on the other side. Servers only do this when the client supports it, so older clients keep working.

🌊 Open-ended streaming (CEP-41) A server tool can now send a live stream of data back to the client while a request is still running, think progress, partial results, or log lines. The client reads it as an async stream, and the final normal response still arrives at the end. Streaming is negotiated automatically with clients that support it.

🌍 UniFFI bindings, write ContextVM in your language The SDK now ships bindings for Python, Swift, Kotlin, and C/C++, all built on the same Rust core. That means native support on mobile, backend services, and scripting runtimes. There's a runnable examples/python/ folder to get you started.

Plus: smarter relay resolution (CEP-17), richer server announcements (CEP-6), optional human-friendly server profiles (CEP-23), progress-aware request timeouts, and an MSRV bump to 1.88.

Huge thanks to

for the job on uniffi bindings, and

for all the hard hork!

Ready to build on this? Read the docs and ship your first ContextVM server or client today: https://docs.contextvm.org/

And we have more news for today… hold on tight!

You can also use the SkateSpots server through the https://contextvm.org/chat interface 🛹

CEP-8 can now talk directly to AI agents. 🧵

With the just released ContextVM SDK 0.13.0 we're shipping full support for a new CEP-8 mode called Explicit Payment Gating.

Why we built it: CEP-8 already let servers charge for their tools and capabilities, but only "behind the scenes", payment was handled silently by the transport layer. That's great for a wallet app. It's not great for an AI agent that actually needs to decide whether a call is worth paying for.

The fix: Agents reason through normal MCP responses, so we turned payment into one. Now a paid call returns a clean "Payment Required" error (-32042) that carries human-readable instructions and one or more payment options. Feed that straight to your LLM, it reads the instruction, pays the invoice its own way, and retries the same call. No special SDK knowledge required, and it works with any MCP-compatible agent runtime.

This design is based on the MPP spec and inspired by HTTP's 402 Payment Required status code, a long-reserved error code for exactly this idea, now adapted for JSON-RPC and AI agents.

What it unlocks:

• AI agents that natively understand and handle paid MCP capabilities
• Per-call budgets and consent at the agent layer
• Payment as a first-class decision: pay, decline, or escalate to a human

Under the hood, each successful payment grants a single-use authorization that's matched to the exact same request on retry, and a "Payment Pending" error (-32043) keeps verification from spamming invoices.

Fully backward compatible, the existing silent "transparent" flow stays the default, so nothing breaks for current users.

Try it: Upgrade to @contextvm/sdk 0.13.0 and turn on a paid capability with explicit gating.

Docs: CEP-8 spec — https://docs.contextvm.org/reference/ceps/cep-8/ Explicit gating guide — https://docs.contextvm.org/how-to/payments/explicit-gating/ API reference — https://docs.contextvm.org/reference/ts-sdk/payments/explicit-gating/

Go build something agents can pay for. 🔌

#ContextVM #MCP #AI #Bitcoin #Lightning #Nostr

This is also a great example of what CVM allows, a full CVM server running in a browser tab! 🤯

ContextVM makes it easier to deploy your self-hosted infrastructure — No domains, no OAuth, no port forwarding!

🚀 @contextvm/mcp-sdk 1.30.0 — 41% smaller bundles, opt-in validation

New patch for our lightweight stdio-focused MCP SDK fork. Two lightweighting wins, zero protocol changes:

📦 Tarball: 2.4 MB → 1.2 MB (−50%) Dropped unreferenced CJS type declarations and source maps that were shipping but never used.

🗜 Consumer bundles: −41% gzip

• Client + stdio: 90.4 → 53.1 KB
• McpServer + stdio: 97.6 → 60.1 KB

The big win: JSON Schema validation (ajv) is now opt-in. Most apps define tools with Zod (validated natively) but never actually validate the JSON Schema they receive over the wire, so they were shipping 37 KB of ajv for nothing. Now ajv only lands in your bundle if you explicitly need it.

No breaking protocol changes. McpServer's own tool input/output validation is untouched. Existing apps that relied on default validation just need to pass the validator explicitly to re-enable it.

⚡ Smaller install, smaller apps, same CVM.

Alongside this new release, we’ve published a new version of our TypeScript SDK (@contextvm/[email protected]), which includes this lightweight MCP SDK along with other fixes for open streams

Have you already tried our new website chat? This chat connects directly to MCP servers exposed through ContextVM, using your favorite LLM!

https://contextvm.org/chat

We just got a PR merged into the official MCP Rust SDK! Contributing to upstream feels good man! 😎

https://github.com/modelcontextprotocol/rust-sdk/pull/858

We recently released a new version of our TypeScript SDK, v0.12.0!

For this version, we forked the official MCP ts-sdk and stripped out all unnecessary dependencies for our project. Many features, such as HTTP transport are useless in ContextVM!

Check it out!

https://github.com/ContextVM/sdk/blob/master/CHANGELOG.md#0120

Now researching about Angine de Poitrine:

This is another brief demo of our latest chat interface at https://contextvm.org/chat. This time, we're connecting to the https://wavefunc.live/ metadata server, which gives you useful tools for searching music metadata using the MusicBrainz API. We searched for Nina Simone. Pretty cool, to be honest. This is a great music research tool.

If you want to test this, just open https://contextvm.org/s/bb0707242a17a4be881919b3dcfea63f42aacedc3ff898a66be30af195ff32b2 , connect to the server and navigate to the chat route

Also, if you want to chat, share, or clear any doubts, we have a group on Signal and also on Discord. Feel free to join!

https://cordn.net/chat/3f5a6278-a38e-4079-840f-4e7523773f38?m=eyJuYW1lIjoiQ29udGV4dFZNIn0%3D

https://signal.group/#CjQKIOgvfFJf8ZFZ1SsMx7teFqNF73sZ9Elaj_v5i6RSjDHmEhAB3wO1Rg-0gLNdusnb3wLR

We’ve just updated our documentation https://docs.contextvm.org to follow the https://diataxis.fr , which aims to bring more clarity and structure to it. We’ve also added documentation for the Rust SDK we recently released.

Additionally, remember that we also have Skills to provide all necessary CVM documentation to LLMs.

Happy building! 🚀

ContextVM makes it easier to deploy your self-hosted infrastructure. No domains, no OAuth, no port forwarding!

Spectr, a Nostr-powered client, is now powered by Relatr and ContextVM!

Check out this video to see how it works!

New version of the ts-sdk 0.12.0 🗜

For this version, we forked the official MCP ts-sdk and stripped out all unnecessary dependencies for our project. The official SDK comes with many dependencies related to HTTP transports and other unnecessary features for CVM. We simply removed all that fat to reduce the number of dependencies (from 17 down to just 5). This is especially beneficial for lightweight and web clients.

If you want to read more about this fork and what specifically was removed check https://github.com/ContextVM/mcp-sdk/tree/v1.x

There are no other changes besides this. Hope you enjoy the slimmer builds! 🗜

The ContextVM website is quickly becoming the most comprehensive demo of what our protocol enables! Recently we added a LLM chat that allows you to directly connect to servers and use and LLM to use them.

https://contextvm.org/chat

Are you providing any service over MCP? Learn more about ContextVM, and see for yourself how easy it is!

Very pumped to introduce the LLM chat on the contextvm.org website!🚀

https://contextvm.org/chat

It's been long overdue, but we've just released the new version of our site, which now includes a chat interface for working with LLMs. This chat connects directly to MCP servers exposed through CVM, making it one of the most comprehensive demos of what CVM enables.

You can BYOK or use the free models, though be aware the free models are somewhat unstable, and we highly recommend plugging in your own key or connecting to your local Ollama instance. Any API with an OpenAI-compatible interface will work.

You can test public servers or connect to your own private CVM servers.

Here are some demos:

• Using Wolfram alpha and open meteo to calculate the distance between Madrid and Barcelona, and the weather forecast: https://video.nostr.build/d2d61f6b9d548ed1d3fc643363d8a3f1951687d636465e99fe19ea63c6a6d502.webm

• Using Tenor api to find the funniest cat GIFs https://video.nostr.build/0a08fb465ccbceccb85b8eb99196a1eedd782225d9344de00bc3f8697e3de860.webm

• Using Relatr to search for Jack and explain why the score https://video.nostr.build/07167a800b190cd408ba2f39d661a8332677a12a217acee39efb4e00d013f678.webm

This is the agentic web in action. Hope you like this update, and please report any issues if you find them.

Huge thanks to

for moving this forward.

Ephemeral gift wraps have been merged into the nips repo! 🚀

https://github.com/nostr-protocol/nips/blob/master/59.md

The implementation of CEP‑15 (Common Tool Schemas) has been merged into the https://contextvm.org website. This allows servers to define their categories and common tool hashes so they can be discovered and grouped accordingly. The result is a marketplace‑style UX where multiple servers can expose the same tools or use the same categories. Server operators can position their services within these common categories or tools, and users can navigate the marketplace to find the services that best suit their needs.

This is very cool. Very innovative way to use ContextVM and it's latest updates 👀

We are proud to be part of the projects listed on the OpenSats website. https://opensats.org/projects/contextvm 💛

We are working actively to bring our Rust SDK in par with the TypeScript implementation.

You can watch our progress on ISSUE 64 on GitHub!

https://github.com/ContextVM/rs-sdk/issues/64

At ContextVM we believe in protocols over platforms.

We believe in cryptographic keys over accounts.

We believe in direct value exchange over third-party intermediaries.

Your infrastructure, your rules.

CEP‑41 has finally merged, bringing the ability to create open‑ended streams. These streams are intended for servers that stream data to clients, such as events, fragments, or real‑time data. This opens the door to many new use cases. For example, it enables a CVM server to proxy a WebSocket server, like a Nostr relay 👀.

We can imagine numerous interesting applications: AI/LLM streaming APIs, chat servers, real‑time feeds, or any other system that relies on data streaming.

You can read the specification on our docs page https://docs.contextvm.org/spec/ceps/cep-41/

A reference implementation is also available in the TypeScript SDK 0.11.x family.

Happy building! 🚀🚀

This is an amazing idea, CVM being used to run state machines 🤌

Stats powred by Nanalytics by

CEP-8 is the ContextVM standard for decentralized pricing and processing payments for capabilities.

When a client requests a capability, an MCP server can send back a notification providing all the information needed for a payment to occur. Specifically, the server advertises the price requested for its capabilities and the types of payment accepted (known as PMI).

Let’s examine it from a more technical perspective:

1. Capability Request: The client requests a capability (such as a tool execution) without prior payment.
2. Notification (payment_required): If the server requires payment, it pauses the request and emits a notifications/payment_required event containing the numeric amount, the pmi, and a pay_req opaque string (the actual invoice or payment data).
3. Payment Processing: The client parses the pay_req according to the specified PMI rule set and executes the payment.
4. Notification (payment_accepted or payment_rejected): The server verifies the settlement. If successful, it emits notifications/payment_accepted. If the payment is invalid or insufficient, it emits notifications/payment_rejected.
5. Capability Fulfillment: After a successful payment_accepted notification, the server processes the original request and returns the result to the client.

The beauty of CEP-8 is that it does not mandate a specific payment method. Any server operator can decide and advertise the preferred rail for the payment to occur. There is also an alternative payment lifecycle for bearer assets that reduces round trips. We are also working on updates to make this more suitable for LLM agents. If you want to learn more, visit: https://docs.contextvm.org/spec/ceps/cep-8/

New informational CEP has dropped!

This is CEP-35, which standardizes functionality already present in our TypeScript SDK, specifically, stateless operations.

Typically, MCP servers and clients use an initialization lifecycle to negotiate capabilities. However, if you don’t need a long-lived session with a server, or if you already know the server’s supported capabilities, this lifecycle introduces unnecessary overhead.

Stateless mode addresses this by allowing clients to make one-shot requests to servers. It’s lighter, reduces roundtrips, and simplifies interactions.

While this functionality has been available for some time, we wanted to standardize it further as we advance the Rust SDK. This ensures parity and sets clear expectations and conventions across different implementations.

Read more in the CEP-35 spec:

https://docs.contextvm.org/spec/ceps/informational/cep-35/

At ContextVM we believe in protocols over platforms.

We believe in cryptographic keys over accounts.

We believe in direct value exchange over third-party intermediaries.

Your infrastructure, your rules.

A large part of the latest updates was thanks to the SoB students. Thanks, guys you rock! 🔥

We continue shipping! A new version of the CVMI CLI, 0.3.0, is available. This time we integrated the last sparse CLI that had not yet been included, CTXCN.

The new command in CVMI is npx cvmi cn; the functionality is exactly the same then the previous CTXCN. Some minor bugs have been squashed, and the config‑file naming convention has changed to be more consistent with the 'cn' command. Apart from that, everything else remains the same.

This is the final integration needed to bring all previous sparse CLIs into CVMI, making it truly the Swiss army knife for the CVM ecosystem 💪

To update, just run npx cvmi@latest.

CEP-23 is now merged, and TS SDK 0.9.0 ships support for publishing server profile metadata (kind:0) directly from the Nostr server transport.

This standardizes a pattern we were already seeing in the wild: servers using the same pubkey not only for protocol operations, but also for profile metadata and public social communication on Nostr.

With CEP-23, servers can optionally publish kind:0 for human-friendly identity metadata and kind:1 notes for updates, changelogs, and operator communication, without changing the existing discovery model.

kind:11316 remains the machine-readable capability surface. kind:0 and kind:1 add the social layer.

A small addition, but an important step toward making ContextVM servers more legible, interoperable, and present across the wider Nostr ecosystem.

CEP-23 + TS SDK 0.9.0 are live. Skills are updated as well. Happy building

https://docs.contextvm.org/spec/ceps/cep-23/

Happening in about 10 minutes.

Do you want to know more about what ContextVM is, how it works, and what the recent developments are?

Join our first community call, Thursday 16th @ 4PM UTC

https://honey.hivetalk.org/meet/ContextVM

https://honey.hivetalk.org/dashboard/event/naddr1qvzqqqrkdypzq6ehsrhjjuh885mshp9ru50842dwxjl5z2fcmnaan30k8v3pg9kgqyv8wumn8ghj7un9d3shjtngd9mx2arpd34jummjvuqq5um4wpekcvmhvdhnqnuezx6

ContextVM TS SDK 0.8.0 is live, with CEP‑22 oversized‑payload transfer.

Large payload delivery over Nostr relays is now much more robust. We even stress‑tested it by pushing a 1.5 MB image over regular relays, partly to check robustness and partly for fun :) It worked, but keep in mind that this is not a general‑purpose file transfer protocol

If you run a server or client on the TS SDK, update to 0.8.0. The CVMI CLI was also bumped to include it.

We keep pushing boundaries 🚀

If you are curious about the underlying specification you can read it here: https://docs.contextvm.org/spec/ceps/cep-22/

We bring amazing news! ContextVM has been invited to participate in the Summer of Bitcoin program. https://www.summerofbitcoin.org/

This is a global, online summer internship program focused on introducing university students to Bitcoin, Nostr, and open-source development and design. We’re very glad to have been chosen as mentors.

We’d also be grateful to hear your project ideas for a student to work on for ContextVM during the summer. Please share any you have. What would you like to see in ContextVM?

🚀

https://contextvm.org/s/nprofile1qyd8wumn8ghj7un9d3shjtnrdah8getcw3mx6tn0wfnj7qpqvk3nfvp0tyfu7tqlwvmkq3xlzyj5zen8de75n8gvxn3v5yx08ctq06sg4p

Setting up an MCP server to be used by AI agents requires a lot of skills, managing domains, OAuth, port forwarding.

ContextVM changes the game, reducing the burden for running a remote MCP server!

Thanks for the help reposting this; we got some new subs :)  really appreciate it.

GM! As you know, we are trying to get the word out on ContextVM to the broader internet by launching our Substack! If you are already on the platform feel free to subscribe! We want the project to grow outside of our niche and we need your help to bootstrap the publication! Here is the link: https://contextvm.substack.com/

Just another quick demo. Same thing, but this time, instead of using the CVMI call command to access the server, we are connecting to the server as if it were a locally running MCP. This is possible thanks to the CVMI use command, which allows you to use CVM servers anywhere you can configure MCP servers.

Just testing this new 'Am I Exposed?' public server someone made online 👀 This is a Bitcoin on‑chain privacy scanner. We wanted to test it to see how it works. This is a short demo of using it together with the CVMI call command. It’s quite straightforward; we didn’t need to touch any other configuration files, just add an alias. The complete process and demo are in this video.

Lazy yet productive Saturday. Stabilized relays from the spam attack and forked Strfry during the process. Contributed to https://ants.sh by

to add relatr for search capabilities. Touched grass

This should be fixed now 🫡 As a side effect, we forked Strfry to add a convenient way to deploy a relay and some write policies to harden it for CVM usage. https://github.com/ContextVM-org/strfry-cvm

Spam attack in our relays. Fixing now

Use it from contextvm.org or through the CVMI CLI.

1. Configure an alias for easy calling:
   npx cvmi config add ots nostr:nprofile1qyd8wumn8ghj7un9d3shjtnrdah8getcw3mx6tn0wfnj7qgmwaehxw309aex2mrp0yezucm0de6x27r5wekjummjvuhsqg8pc8pjw2wt64pvnwww0mnwggwyxns8sdfzsqsvfat3gpuz7qjfdg9k5kv0

2. OTS an event:
   npx cvmi call ots ots_event target=<event-id‑nevent‑naddr>

3. Verify the attestation and get its state:
   npx cvmi call ots verify_ots target=<event-id‑nevent‑naddr>

If you want, you can configure it as an MCP in your preferred agentic framework; just set npx cvmi use nostr:nprofile1qyd8wumn8ghj7un9d3shjtnrdah8getcw3mx6tn0wfnj7qgmwaehxw309aex2mrp0yezucm0de6x27r5wekjummjvuhsqg8pc8pjw2wt64pvnwww0mnwggwyxns8sdfzsqsvfat3gpuz7qjfdg9k5kv0 in your MCP configuration.

🕰 New public server available! 🕰 This is an OTS client that lets you easily Open Time Stamp any Nostr event. The usage is straightforward: two tools, 'ots_event' to create an attestation for an event, and 'verify_ots', which lets you verify the OTS attestation and its state in the time chain.

With this server, you or your agents can easily OTS any Nostr event. Here’s a brief demo:

The project’s code is open source, and you can run your own instance if you wish. By default it uses public Bitcoin nodes to verify the attestations, so you don’t need to run your own node.

https://github.com/ContextVM-org/ots-cvm

Server page: https://www.contextvm.org/s/e1c1c32729cbd542c9b9ce7ee6e421c434e07835228020c4f57140782f02496a

You can use this service for free, but public OTS servers need to cover operating costs. If you’d like to donate, please refer to opentimestamps.org.

🌍 New issue of the ContextVM world newsletter 🌍

In today’s update we cover CEP‑17, the latest specification change to the CVM protocol. This change allows MCP servers to announce the relays for establishing connections, making it easier for clients to discover them. We also discuss new CVMI capabilities and other news from the ecosystem, plus demos and a new Rust SDK that is currently being built. Hope you enjoy it!

Don’t miss any issue, subscribe to our Substack.

https://contextvm.substack.com/

Make your MCPs over Nostr, composable, token efficient, easy 🚀

#mcp

The cool part about the demo, ahead of the reduction in token usage compared to building this with the MCP interface, is the progressive disclosure. The LLM didn’t know anything about Earthly, Wolfram, or Relatr, and it discovered tools and usage as needed. No extra tool schemas were loaded unnecessarily, no bloated context window, just organic discovery and usage.

We’re thrilled to roll out CVMI CLI 0.2.x, adding two powerful commands: call and discover.

call lets you invoke CVM servers straight from the command line, perfect for debugging or plugging into agents. No MCP config or schema loading needed; responses are cleaned to save tokens. Save servers with aliases and run them like npx cvmi call relatr.

discover query relay announcements to list available tools, just run npx cvmi discover.

Demo: query Earthly and Wolfram for the Eiffel Tower’s address and height

Get Sovereign Engineering pubkey using Relatr.

These upgrades make CVM servers far easier to use and compose, cut token costs versus MCP, and give developers a simple way to debug, script, or integrate CVM services from the command line.

Some screenshots of this new capabilities:

🚀 CEP-17 is now merged into ContextVM, and it is available in the ts SDK from v0.7.x.

https://docs.contextvm.org/spec/ceps/cep-17/

This is a meaningful step forward for resilience. With CEP-17, servers can publish the relay list they use following NIP-65, and clients can resolve connection paths more intelligently: first from explicit configuration, then from relay hints embedded in nprofile, and then if nothing is define from relay list discovery. That makes connectivity more robust by default, reduces dependence on central points of failure, and avoids hardcoded relays in normal client setup.

It also makes client configuration simpler. In many cases, you can now just pass an nprofile string and clients will use its relay hints directly; if those are not available, it can fall back to CEP-17 discovery through NIP-65 relay-list metadata.

The reference implementation is already in the SDK, the docs and skills have been updated, and contextvm.org now surfaces these new nprofile identifiers as well. Small change in surface, big improvement in how reliably clients can find and reach servers across a more sovereign network 🚀

We’re so back. DNS problems have been resolved, sites and relays are reachable again 🚀

We've been having problems with DNS and registrars, which is why our ContextVM websites are down. We have a pending transfer that should be resolved soon. In the meantime, we’ve deployed the main site and documentation on GitHub Pages as a backup alternative. The links are:

• https://contextvm.github.io/contextvm-site/
• https://contextvm.github.io/contextvm-docs/

Sorry for the inconvenience. CVM servers are still running, and clients can still connect using any relay, there’s no disruption there 🦾

Nostr == WS == CVM. Connecting to servers, calling tools, etc, everything has worked over WebSockets since day one with ContextVM 🚀

Continuing with NIPs, we have just added a pr for CVM to the NIPs repository. We wrote this NIP to describe the conventions for transporting Model Context Protocol (MCP) messages over Nostr. We deliberately kept the NIP thin on details that already live in the full CVM spec; it exists to make CVM discoverable in the Nostr ecosystem and to show that CVM is just Nostr, using the same primitives any Nostr app uses.

https://github.com/nostr-protocol/nips/pull/2246

We just opened a PR in the NIPs repo that includes this convention for ephemeral gift wraps. Perhaps other developers will find it a valuable building block

https://github.com/nostr-protocol/nips/pull/2245

Ephemeral giftwraps improve your privacy and hygiene on relays, as nothing is persisted there. CVM messages use ephemeral events when the traffic is not encrypted, but when encrypted, they wrap the ephemeral events in a gift wrap which uses a regular kind. So even if the wrapped event is ephemeral, its envelope isn't. Ephemeral gift wraps solve this; everything is encrypted end-to-end, relays just route blindly, nothing is persisted, no collect now, decrypt later 🥷🏼

CEP-19 is live with ephemeral gift wraps 🚀

In plain terms, you can now send end-to-end encrypted MCP messages that do not have to be stored on relays. This is a significant upgrade for privacy, as your messages can travel through public infrastructure without becoming permanent data. The kind used by CVM is ephemeral (25910), and when you use encryption, this ephemeral kind is gift-wrapped (NIP-59) in a regular event kind that is persistent on relays (1059). With this update, servers and clients can use a new kind for ephemeral gift wraps (21059). It is exactly the same as the regular kind (1059) but is ephemeral, so it is not stored on relays. This also improves metadata hygiene: relays can forward messages without needing to retain payloads.

How it works: CEP-19 introduces an ephemeral gift-wrap kind alongside the existing persistent kind. Both sides advertise their support, and when both do, the transport prefers ephemeral wrapping while maintaining backward compatibility with older clients.

Configuration in the SDK: This feature is available from version v0.6.0. Just set the transport’s GiftWrapMode option to EPHEMERAL to always use ephemeral gift wraps, PERSISTENT to force legacy behavior, or OPTIONAL to negotiate ephemeral wrapping when supported. The default remains compatible with existing relays and clients, making this an opt-in privacy upgrade without being a breaking change.

Hey Nostr! We're excited to share that we're working on getting more eyes on ContextVM and its development. We just published our first post on Hacker News. If you're on the platform, we'd love for you to check it out, share your thoughts, or help spread the word. Every bit helps, so please join us in growing ContextVM! 🚀

https://news.ycombinator.com/item?id=47151294

Now that payments are in place, we are going to work on:

• CEP-19 for ephemeral gift wraps: https://github.com/ContextVM/contextvm-docs/issues/19, and
• CEP-17 for servers relay list: https://github.com/ContextVM/contextvm-docs/issues/17.

Both CEPs are quite minimal but yet beneficial for the ecosystem. CEP-19 provides better privacy guarantees, as servers and clients will be able to use ephemeral gift wraps for encrypted communications. Currently, they use regular gift wraps, which are regular events, and even if the events inside are ephemeral, they are wrapped in a regular envelope. CEP-17 defines how servers can announce relay lists (NIP-65) to improve discoverability.

Simple but powerful! LG!🚀

After this iteration we will come back to CEP-15 introducing common tool schemas, which is a bigger one

https://github.com/ContextVM/contextvm-docs/issues/15

We've just released a new version of our SDK, now CEP-8 implementation is now complete, end to end, we’ve added the missing piece for LLM aware spending

CEP-8 gives us the wire protocol for paid MCP capabilities, servers request payment, clients settle, both sides get explicit confirmation. What was missing was a clean way to make consent programmable. This release adds a single paymentPolicy hook at the client boundary, a little yet powerful new addition. Your host environment decides whether a charge proceeds: a deterministic budget, a per-tool allowlist, a terminal prompt, or a full LLM-based policy engine. One hook, any pattern.

Google's AP2 addresses a similar problem, but it's an ambitious multi-actor framework involving Shopping Agents, Credential Providers, and cryptographic Mandates passed across multiple parties, quite complex. Our take is different, CEP-8 provides the payment rails, Nostr anchors every request to a cryptographic identity at the transport level, and consent is a composable local primitive. Simpler to integrate, and versatile enough to fit whatever your host needs to do.

This our take on agentic payments, simple, versatile, composable, no vendor lock ins

After a few days experimenting and receiving feedback around CEP‑8 payments, we enhanced their SDK implementation, making payments more reliable and consistent. We’ve just released a new feature that supports additional use cases, such as servers with prepaid balances, top‑up accounts, or separate payment management. This feature lets you waive a payment via the server’s resolve price callback. With this update, payment processing is far more powerful 🚀

Docs and skills have been updated accordingly. Happy building :)

Docs: https://docs.contextvm.org/ts-sdk/payments/overview/#waiving-payment-prepaid--subscription-models Skills: npx cvmi add --skill payments, or npx skills add contextvm/cvmi --skill payments

We are at speed now, and you can find our latest issue of the newsletter on our Substack! https://contextvm.substack.com/p/the-contextvm-world-2

Get it fresh in your inbox every two weeks!