Today, AI Agents are becoming increasingly popular, but everyone is relying on centralized solutions:

• Inference is done using OpenAI or similar centralized companies that log and sell all your data
• Agents are running on centralized servers and cloud solutions like AWS, GCP or Azure

While we start to see agents interacting onchain with wallets, it's time to make them use decentralized solutions and give them a way to become truly autonomous and unstoppable.

But this technical improvement shouldn't come at the cost of accessibility and ease of access, good interfaces and abstractions are also needed to allow any human being to deploy his very own unstoppable agent.

That's where CreAItors comes in 🔥

We provide a framework for developers to build AI Agents that use private & decentralized inference and can pay for their own computing on a decentralized cloud with a wallet that only them control.

These agents can then be published on our marketplace in a few minutes, allowing anyone to spin up its own instance and version of this agent.
Several customization options are available, including the strategies to stay alive by staking $ALEPH tokens faster than they are spent for the computing power, the built-in ability for the agent to kill itself if it deems it necessary, or the redistribution of the agent revenues to its creators.

With our interface that is accessible to everyone (login possible with Google and Coinbase Wallet in addition to traditional crypto wallets, payments in credit card via Coinbase Onramp...), nobody is left behind and deploying an own autonomous and unstoppable agent is just a few clicks away!

Introduction

CreAItors is available through our decentralized web UI (deployed on IPFS with Aleph Cloud).
Users can access it at https://creaitors.andresmolins.dev/, where they can login with different providers to create and deploy agents.

Authentication

Our project supports 2 login providers:

• OnchainKit, which allows crypto-native users to connect with Coinbase Wallet, Metamask, or even Phantom for Solana.
• Okto with Google social login to easily onboard anybody, without crypto knowledge required.

Creating an agent

Our project gives developers access to a Python framework to easily create AI Agents that can pay for their own computing (published on PyPi).
After creating their agent and pushing it to a GitHub repository, "creAItors" (aka developers) can login in our marketplace and click the "Upload AI Agent" button.
They will then have to fill some metadata about the agent (name, description, image...) and upload a .zip file with the agent code (that can be directly downloaded from GitHub).
After signing a few messages to upload it on Aleph's decentralized storage, the agent will be visible in the marketplace and anyone will be able to deploy an instance of it.

Deploying an agent

Anyone, no matter their technical level, can use our marketplace to deploy an unstoppable AI Agent.
To do this, they simply need to log in, search for the agent they want (using categories filtering and/or name search), and click deploy.
They will then have to give it a name, configure some variables to make it behave the way they want, fund with a small amount of ETH on Base the address of the agent (to pay for its first hours of computing, doable by credit card with Coinbase Onramp for people not familiar with crypto), and wait for the agent to be deployed.
Finally, they can check the logs of the agent's though process in their "My agents" page that displays all their deployed agents.

Frontend

The marketplace is a simple NextJS app built with TypeScript and TailwindCSS with shadcn. It uses Aleph Cloud's SDK to upload & pin files on IPFS and store messages on their decentralize network, acting as our agents database.
The agent creation basically just consists of pushing data to Aleph so it becomes listed in the marketplace.
To deploy an agent, we ask the user to sign a message, with is sent to the backend and used to generate a wallet (more details in the backend section).
The wallet address is then displayed and should then be funded by the user (ETH on Base mainnet, with a manual transaction, automatic with Okto, or using Onramp for credit card payments)

Backend

The backend uses the message signed by the user to generate a wallet by running a SHA3-256 on a string combining a fixed message, the signature hash and the UUID of the agent.
When the wallet is funded with ETH, it uses the web3 package to perform a swap on the Uniswap WETH/ALEPH pool for a calculated amount of ALEPH, then initiates a Superfluid stream to Aleph to start an instance, and deploys the agent on it with a simple shell script + Dockerfile, while also injecting environment variables that include the wallet private key.
Login in the instance is done with a randomly generated SSH key that is not logged and forgotten after the deployment, making the agent truly independent in his instance (the same goes for the wallet address).

Agents framework

Built as a wrapper of LibertAI Agents framework, we use AgentKit to provide a wallet to the agent, with a custom action provider containing actions to get information about the computing status (tokens consumption rate, balances, prices...), perform a swap of ETH for ALEPH, commit suicide (stopping the Superfluid stream that pays for the instance) or redistribute revenues to its creators.
The "self-funding" thinking to buy tokens or not is launched at a customizable interval.

CDP products

We use various SDKs and products in our project:

• AgentKit is used in our AI Agents framework to give the agent access to a wallet, with a custom action provider for the self-funding mechanism
• OnchainKit is used in our frontend to:
  • Authenticate with Coinbase Wallet or Metamask
  • Sign messages and send transactions (to create and deploy agents)
  • Allow users to use Onramp to pay with traditional payment methods instead of using crypto

Base

Every onchain interaction happens on Base:

• Agent wallets are funded with ETH on Base
• Computing is payed with a Superfluid stream of ALEPH tokens on Base
• ALEPH tokens are bought on Uniswap by the backend and the agent, making transactions on Base
• Okto social login also create a Base wallet in the background

Okto

We are using Okto social login with Google to allow users not familiar with crypto to log in with an account that is familiar to them.
The Session Keys allow us to simplify and speedup the agent deployment flow by abstracting the multiple message signatures and the wallet funding transaction.
Although we didn't had time to implement it, adding Okto as an option for the Agents wallet is also a very interesting possibility for an even easier process.

Aleph Cloud

Our whole platform is built and deployed on Aleph's decentralized cloud:

• The frontend is published & pinned on IPFS via Aleph, with a custom domain
• The backend is deployed in an instance of the decentralized network
• The agents are also deployed on these kind of instances
• Files are stored on IPFS pinned by Aleph
• We are using Aleph as a database by publishing the agents metadata on the network messages

LibertAI

We are leveraging this private AI project (that is itself built on Aleph) by building our framework and "self-funding of hosting" feature on top of their existing AI Agents framework, that uses LLMs deployed on the Aleph network, without logs or tracking.

Frontend

• Okto social login with Google
  We encountered an issue where only the React component was working and not the hook to trigger the login ourselves (needed for a good UX as we also have OnchainKit for login). We just hid the component and forced a click on it when our UI button was clicked.
• OnchainKit custom modal trigger
  Similar to the issue with Okto, the login modal wasn't exported from OnchainKit to trigger it programmatically. We made a PR to fix it, but in the meantime used a fork version of the package.
• Coinbase Wallet signatures
  When signing string messages, Coinbase Wallet is using eth_signTypedData whereas all the other wallets (Metamask, Okto) are using personal_sign. We didn't manage to force it to use personal_sign (as some of our other dependencies don't support the verification of eth_signTypedData signatures), so Coinbase Wallet isn't working for some flows that require signatures.

Backend

• TEE deployment
  Pushing for full confidentiality while using a backend isn't perfect (even if deployed on a decentralized cloud), with more time we would have deployed it on a TEE with verifiability of the code executed.
• Remove the backend
  Pushing for full privacy / confidentiality while using a backend isn't perfect (even if it's deployed on a decentralized cloud). Ideally we would like to get rid of the backend completely by starting the instance from the user wallet, generating the wallet directly on the agent's instance, and then switch the payment flow to the agent wallet, but not possible yet with Aleph.

Agents framework

• We have no real example of agents making money yet, as we were focusing on the framework
• Not a lot of type autocomplete (which is good for a framework, also documentation...)
• We wanted to add the ability for agents to create other agents, but didn't had time
• Also adding the ability to communicate with other agents is a planned improvement