Note: The following blogpost is part of a series of old writeups I did on various DePIN and DeFi projects across the latter half of 2024.

It’s likely that some of the content is out-of-date or no longer reflective of the current state of the project discussed. I’ll leave notes here and there for some updates, but I’m keeping those minimal. Regardless, I’ve decided to post these here anyways for posterity. The writing style may be a little inconsistent and unstructured, but hopefully the reads are still entertaining.

A Look into “Morpheus AI”

Founders

Supposedly anonymous founders, whitepaper authors don the pseudonyms “Morpheus”, “Trinity” and “Neo”.

Given that Morpheus builds off “Smart Agents” (https://www.smartagent.org/) and the latter explicitly makes reference to Morpheus as its “local implimentation (sic)”, it seems like the devs for SmartAgents are likely responsible for Morpheus as well.

I don’t understand the need for the incessant Matrix references besides mystic, aesthetic and “vibe”.

Team

Claim from their Discord: “Morpheus is fully decentralized and driven by a community of open source contributors.”

Cross referencing the GitHub pages for both SmartAgents and Morpheus, we find the following individuals:

• David A. Johnston (Twitter, GitHub, LinkedIn)

  • Responsible for the SmartAgents framework, heavily involved in both Morpheus and SmartAgents as a developer
  • He’s the one who init the Morpheus GitHub repo, uploaded the WP, YP etc. so let’s just assume that he’s also the “founder” of Morpheus

• Scott Berenzweig (GitHub, Twitter, LinkedIn)

  • Appears to be another key dev for both SmartAgents and Morpheus
  • Bulk of docs have been uploaded or updated by this guy

• Anton B. (LinkedIn, GitHub)

  • Despite being second highest in terms of commits, he seems to only be responsible for translations of docs to Russian and Ukranian
  • Could be trying to game the token distribution (refer to document 3)

• Jason Buchanan (GitHub, Twitter, LinkedIn)

  • Appears to have been involved early on in both projects, but has had no appreciable activity concerning them recently

Other contributors involved do appear to be independent devs, the key incentive for contributing appears to be the allocation of MOR tokens that go towards Coders, where ones contributions are weighted and your allocation is determined by that weight.

From contribution history alone as well as social media activity, it seems like David and Scott are the key minds behind both SmartAgents and Morpheus, being their primary contributors.

Smart Agents

Smart Agents are supposed to be the core of Morpheus. They’re meant to be finetuned LLMs that pick out contracts to use (after translating your commands) through a “Smart Contract Rank” (which is 1. not live 2. extremely subjective 3. probably gameable).

There exists no actual implementation of this framework as described, and what can at best be called a “loose interpretation” of it exists on the Morpheus repo (more on that later)

First Blush

Before we can look into Morpheus, we first have to understand what the “Smart Agents” are.

Demo WebApp is non-functional: https://www.chatweb3.org/ and is still “under construction”. Not promising.

Website also looks very plain: https://www.smartagent.org/, links point to https://mor.org/, misspelled “implementation”. [Update 15/01/2026: The site looks even fucking worse now, which is quite the achievement.]

Two other links point to Smart Contract Rank (we’ll look at this later) and SmartAgency.AI (meant to link up devs to clients who want custom smart agents).

Whitepaper

• Smart Agents are posited as a “neural protocol”, which is a pompous way of saying “fine-tuned local LLM that can interact with smart contracts”.

• Quote: “Each day the user confirms their Smart Agent is benefiting them and acting according to their goals by approving the actions it prompts the user to take.”

  • Not some fully automated LLM solution, still requires human approval for tasks

• Quote: “All secured with cryptography that is impossible for an AI to generate or fake.”

  • Sounds like fluff, just states value proposition of crypto in general

• Incentive model: devs create smart contracts the the LLM can interact with. If the smart contract generates yield (e.g. ETH staking), then a cut of the yield is “donated” to the dev.

  • Why should I interact with contracts that take a cut? And are these not just contracts which already exist and are just modified to a) be easier(?) to interface with for the LLM and b) take a commission?

• Local Smart Agent is just AutoGPT with Web3 wallet integration

• Quote: “Developers that contribute to this software will gain part of the ETH yield from the Staking and other default programs running on the software”

  • Need to look into the “other default programs”

• Quote: “The core benefit of the Smart Agent approach is to deeply connect / tether their AI to peoples’ private keys. It’s truly the one thing AI cannot generate.”

  • I still don’t understand the emphasis on this point, right now what I’m hearing is just there being an LLM that acts as a proxy for a human to interact with dApps and nothing more.

Proposed Task Implementation

“One of the modules is based on the task.mstr file, which logs what the Smart Agents do for the Smart Agent Owner. A task assigned to a Smart Agent is named with a .tsk extension. i.e. StakeEth.tsk.

A Smart Agent can have only one .mstr file, which records the status of its origination time, software version number, module configuration and tasks performed through the life of the Smart Agent. Published on the Ethereum blockchain (potentially moved to Polygon to reduce gas costs), this log condensed adds a layer of security since no two Smart Agents can ever have the same .mstr file, i.e an “Smart Agent_ID”.”

I cannot find any examples of these files in the repo. It is also unclear why they’re publishing logs based on this .mstr file.

Yellowpaper

• Quote: “Smart Agents let people talk to Smart Contracts with confidence because Smart Contract Rank to showing them the most used and decentralized options. So, a new adopter of crypto will use their Smart Agent as a guide.”

I think we should address the Smart Contract Rank.

Supposedly, devs would publish smart contracts that are compatible with the local Smart Agent LLM stack. Then, the contract is scored based on the number of transactions performed with it, the “Dapps score” and the “DeFi Score”

• The “Dapps score” is based on “how many of 10 values listed in the Smart Agent paper are implemented by the Blockchain the Smart Contract operates on”
• The “Defi score” is “calculated by detailing how decentralized each smart contract’s operations are.”

These are two astonishingly vague conditions. The site itself even posits that these Smart Contract Ranks would be published via an API on their site, which seems to go against the ethos of “decentralisation”.

• Pipeline seems to be built atop langchain.

  • This pipeline also seems to be needlessly complicated and confusing.

• Quote: “For dapps outside the Smart Contract Rank algorithm, all financial transactions will add a 10% to the user.”

  • … what?

SDKs

No SDKs seem to have been developed.

Test Application

From the looks of it, the “SmartAgents” framework as a standalone has been largely abandoned and is basically indistinguishable from the base LLM that Morpheus provides. We’ll look more into that later.

All in all, the Smart Agent framework does not seem very promising. The tech stack itself is fairly rudimentary and as of right now, seems to only comprise of a local LLM that can interface with dApps and nothing more. The commission system, ranking system seem to add unnecessary complexity without any apparent benefit. On top of that, there do not appear to be any live versions of these products (as a standalone stack) to demo.

Morpheus AI

Morpheus is supposed to facilitate the hookups of users with compute providers to run LLM prompts, of which some prompts will execute Web3 actions. This is Limewire, but for LLMs. There exists no safeguards to actually ensure that the compute provider is running an LLM to begin with, the token distribution system has holes, there is no prompt security (your prompts will be known to the compute provider) and the project is very confused as to what it wants to be.

First Blush

The separation between Smart Agents and Morpheus as products does not exist, and thus lends skepticism to why it is that Morpheus was proposed by some anonymous creators to leverage the “Smart Agent framework”.

It seems like “working versions” of the local LLM are up for grabs on the Morpheus GitHub page (why do they not exist on the Smart Agent GitHub?), so this can be looked into later.

Whitepaper

[Update 15/01/2026: This whitepaper is now out of date. You can still view the version I’m referencing here]

(Personal opinion: I think the Matrix marketing stuff is a bit stupid and cringe.)

• Quote: “To make Smart Agents accessible to everyone and increase decentralization of their infrastructure, we propose the development of the Morpheus network. The Morpheus network will include a fairly launched token (the “MOR” token) for incentivizing all four of the key contributors to the network.”
• The four in question:
  • “Community of builders creating interfaces”
  • MOR devs contributing to agents
  • Capital providers (LP)
  • Supplying computation, storage and bandwidth (how?)

We’ve previously established that the Smart Agent is a local LLM, so it makes things a bit confusing from the get go. Do they have some system to run the LLM in a decentralized manner? (no, they don’t).

• Quote: “What these open-source LLMs currently lack is a standard graphical interface by which users can chat with them, an API for developers, a cloud solution to move between devices and a way to manage user data and the recovery process. This is where the Smart Agent Protocol comes in, as it provides an open-source LLM run locally and is managed by a user’s Web3 wallet.”

  • This point can be very easily refuted with the large number of GUIs and E2E solutions for running local LLMs, especially Llama

• Quote: “However, the local only approach still lacks an API for developers to build on and the cloud solution where a network of users can run the software on powerful hardware to enable use cases such as light clients, where the user doesn’t need to download the full node or Smart Agent locally.”

• Quote: “Running on the decentralized public infrastructure is cheaper than paying Chat GPT a license fee for every new user.”

• Token Distribution

  • 24% goes to compute, “proof of transactions for API calls served”

  • 24% goes to coders based on their merged commits to the main repo

  • 24% goes to capital. Quote: “Proof of stETH yield contributed, 50% swapped for MOR & paired with the rest 50% to lock in the AMM as a Protocol-owned Liquidity (PoL).”

  • 24% goes to community. Quote: “Proof of building front end applications & tools that engage users.”

  • MOR will be used to pay for compute, pay for API calls to LLMs and pay for… training data?

  • Compute flow goes a little like this:

    • User holds MOR, requests for compute, this request is sent to a Router
    • Router matches up the User with a Compute provider
      • This is done through the “lowest Bid per IPS in MOR”
    • Prompt is sent to the provider, response is generated by LLM and sent back (does not go through router)
      • Compute providers also need to hold MOR to “discourage Sybil attack”
    • “User reports success metrics to Router” and compute is rewarded MOR via the compute contract based on this

So far, it sounds like a gameable system, and if not, one that is very subjective. Rewards are determined by loose metrics, and the system which enables “decentralized prompting” is just a system that hooks up users and folk running LLMs. There also appears to be no checks in place that you’re actually interacting with an LLM.

Quote: “Providers should need to prove they have a given LLM, by signing hash of LLM model with their key.”

This implementation needs to be investigated, hopefully it is addressed in the yellowpaper.

Yellowpaper

[Update 15/01/2026: You can view the yellowpaper here, though there may have been changes since.]

Quote: “Audits of Agents performed by Coders generating an “Agent Proof” that the stated functions of the Agent are as presented. And of course contains no malicious code.

Placeholder for description of audit process, who can conduct audits and how to certify their outcomes. Also incentives paid to auditors.

Prompt Proof generated at the time of a user interaction showing the intent expressed, matches the smart contract selection and transaction values are confirmed with the user.”

Not very promising. The details we were looking for haven’t even been written out. Again, the rest of the technical details are quite vague.

An obvious issue is the security of prompts — even if it is a decentralized system, we still want our prompts to remain private and the responses as well. The team proposes Fully Homomorphic Encryption (FHE) LLMs, but they are 1) not a thing yet beyond toy examples and 2) definitely are not currently implemented.

Yellowstone Compute Model

[Update 15/01/2026: You can view the document here, though there may have been changes since.]

This document was (supposedly) written by Erik Voorhees, ShapeShift’s founder. He has spoken about the project and is apparently a community member. The GitHub account used to commit these docs appears to have been made just to add the doc and otherwise has had no activity. Personally, I think it’s suspect, but we can grant the benefit of the doubt.

This document appears to lend further detail to the compute workflow described in the whitepaper and yellowpaper. Here are some highlights:

• AccessRate: the number of prompts and IPS (inferences per second) you’re allowed daily is based on how much MOR you hold.

• Quote: “Providers should need to prove they have a given LLM, by signing hash of LLM model with their key. This doesn’t prove they used it, but it proves they downloaded and installed it, which represents work, thus preventing some forms of sybil-sensitive fraud.”

  • This more or less lines up with what has been mentioned earlier: there is no way to tell if you’re being gamed and there actually is an LLM being prompted here.

• Quote: “If Providers provide garbage results to User, User can send [Fail] along with [milliseconds] back to Router, and Provider won’t be credited for that compute.”

  • Then can I not cause network congestion by simply failing a bunch of providers?
  • This is addressed, quote: “Sybil attacks [via flooding are prevented by AccessRate]”, yet it’s not a particularly strong argument.

• Quote: “Morpheus doesn’t need all answers to be perfect… it only needs enough answers to be good enough, relative to competing alternatives… Pass/Fail is determined by User, and polices quality to some degree. User conveys Pass/Fail result alongside [milliseconds] back to Router. If Fail, either no reward or penalty point (TBD). There is no incentive to falsely Fail a Provider (no monetary incentive in doing so).”

  • Again, marks of a somewhat clunky system.

Smart Contracts

Nothing of note has been implemented. [Update 15/01/2026: It seems like this repo was abandoned and a lot of work was instead done here, the Lumerin Node repo, a few months after I wrote this.]

Router.sol

The heart of the Morpheus’ “decentralized LLM” claim, the contract that’s supposed to enable payouts to compute and hookups between users and providers. It is currently… a whole lot of nothing, quite literally.

MOR.sol

Just an ERC20 token implementation. Nothing else interesting.

I’d look into the other contracts, but giving them a cursory glance, I see nothing relevant to the tech stack that was previously brought up. As it stands, these are just the bare minimum needed for you to mint a token, distribute it and communicate between an L1 and L2.

Nodes

The “node” is just an Ollama wrapper with 1 (one) sample prompt that allows the pretrained, not actually finetuned model to interact with Metamask. It doesn’t even enforce JSON mode or anything, so there is a non-negligible chance that the model would hallucinate midway in constructing the ETH transaction.

There is no “compute providing network”, there is no router, this is not an MVP.

First Blush

So we’ve got something a little confusing going on here.

On the main repo, we’ve got installs and source code for a local model (I’ll look at this later).

We also have links to Morpheus Local Install in a repo called “Node” (since renamed to “Lite-Client”) and a Lumerin Node , which is a different local program?? [Update 15/01/2026: Seems like after writing this, a few months later all work was shifted to the Lumerin Node repo, which is still being worked on to this day.]

Some Notes

Excerpts from the Discord FAQ:

• Is there a platform through which I could provide compute?
  • None at the moment. However, work with Akash is underway to create a template to make this possible in a decentralized fashion.
• Will compute providers be able to use cloud infrastructure?
  • Morpheus is agnostic to how Compute Providers provide Inference Per Second. Akash, Bittensor, Ritual, EdgeLlama, whatever you want.
• How do I provide compute?
  • Currently, there is no way to provide compute as the compute contracts are still under development, however you can still spin up and test the local inference of the node.
• Is running a node the same as providing compute?
  • Running a node is NOT the same as providing compute, compute provision is still being finalized so hold tight for more information.

Summarising: there is no existing system to delegate compute, running a node != providing compute??, they’re happy to make bold claims about how to provide compute before even having an MVP

Lite Client

Appears to have been abandoned.

The Lumerin Model

[Update 15/01/2026: This document is gone!]

• This seems to be just another reinterpretation and reconfiguration of the routing-bidding-distributing system that’s been proposed twice over already
• There isn’t anything new here besides integrating the ideas of the “Techno Capital Machine” (more needless buzzwords, which in brief is just the distribution model to reward coders etc.)
• I don’t know why it’s a separate thing on its own but it’s telling me that the project is very much confused as to what it’s supposed to be.

The “Node” from the main repo

Let’s see how advanced this LLM actually is. Going back to the claims made in the “SmartAgents” section, it should be able to execute Web3 related tasks, provide suggestions, pick optimal contracts, have a system to develop “tasks” and is a finetuned LLM perfect for Web3 users.

I’ll be trying the Windows build in a sandbox.

The experience:

• Hella slow setup time as it appears to be downloading Ollama in its entirety
  • Ollama is just an open source, readily available local LLM wrapper built by devs that are likely far more capable than those in the Morpheus team, whose work is now being piggybacked off
• After about 10 minutes, it is still Initializing
• Looking at the source code, the default model is Mistral (no finetuning whatsoever, of course). This needs a minimum of 8GB free RAM to run, so it probably wouldn’t run properly… if it would even initialize.

Source Code

Assuming that the source code in the repo is one and the same with the distribution, we can take a look at what’s really going on here.

I’ll be looking at the most interesting files as the bulk of it is boilerplate to set up a GUI for Ollama.

agent/app.js

• This is the implementation for a SmartAgent
• Here we can see the system prompt for the model. Summarising it, it just gets the model to use a fixed JSON format and tells it to respond to the user as Morpheus.
• The advanced “memory” is just a text file, “memory.txt”, where your chat log is stored. No Filecoin, no IPFS.

agent/tools/tools.py

• PoC for tools the LLM has.
• I get that it is a proof of concept, but could they not have done more beyond elementary math operations?

agent/metamask-agent/backend/agents/metamask.py

• Example of Web3 integration
• Provides a few sample prompts and responses for the LLM to work off.
• Currently only capable of initiating a transaction from address A to address B

agents/rag_assets/send_eth_transaction.txt

• The advanced finetuning: a single textfile with a sample response that is pulled via RAG
• Barely even qualifies as RAG

Conclusion

• Who are the main contributors, contribution type, contact info/profiles?

  • David A. Johnston and Scott Berenzweig are your big dogs. There is no Neo, no Trinity, no Morpheus. It’s just these guys.

• Why should we be interested in what Morpheus is building? From first glance the mvp seems to be an LLM run by a decentralized network + some customization to translate natural language to EVM transactions.

  • Their value proposition is that they’re giving easy access to LLMs that will be cheaper than getting an OpenAI license. This doesn’t seem to be the case.

• How does it work under the hood? Does it make sense or is it all smokescreens?

  • The basic idea (let people with compute resources run LLMs, let those without such resources get inferences from those LLMs) is sound, but the proposed implementation is needlessly complicated, confusing and inconsistent
  • The rewards system (rewarding of compute providers) does not seem robust and is easily gameable
  • Lots of subjectivity and oddities such as in the inference quality rating, how coding contributions are weighed, etc.

• What’s the state of the project? Is the product live? Can we run it? Key future dates/timeline

  • The project is a mess
  • There is no live product besides the token that’s been deployed
  • You cannot bid for compute because they haven’t even figured out what that is, nor is there anything implemented.
  • There is no roadmap

This looks like vaporwave to me. They’ve come up with a hundred buzzwords (Yellowstone model, Lumerin Node, Techno Capital Machine) to describe what they’re doing, but at the end of the day it’s just a needlessly complex, unnecessarily Web3 P2P LLM prompting system in which anything notable proposed has yet to be implemented in any appreciable capacity.

If you want a quick buck, speculation alone will probably drive the token value. If you want an actual product, this ragtag team of “open source devs” purely incentivized to contribute by receiving a cut of the tokens… it doesn’t seem like they’d be able to deliver on their promises.