Hello World Computer

• We built Hello World Computer, an agentic onboarding experience for Ethereum, live on Base mainnet
• We used Onchainkit, Agentkit, Privy and Vercel AI SDK to create an interactive chat experience
• There were some side quests along the way, but we managed to ship a working demo just in time: code, app, showcase

Having reflected a bit on hackathons in general yesterday, I thought I'd go into some detail about what Elliott, Philip and I ended up building, while it's still fresh in my memory. As well as the obvious objective (fun with friends), I saw this particular hackathon as a twofold learning opportunity - to build something fun on top of an LLM, using some new web3 developer tools.

It's long and I won't apologise.

Hello World Computer

First, the idea. We had a couple coming into the week, some vast and ambitious, some trivially small. I was keen on a game idea, which will remain a mystery, until I build it for real. But in the end we decided to combine two recent attention-grabbing but controversial moments. Firstly, the Ethereum Foundation's "hello world computer" tweet, and secondly Jesse's onboarding efforts on the streets of San Francisco. What if OGs could onboard newcomers to Ethereum with the help of a wallet-bearing agent? Hello World Computer was born.

The "what" was decided, just leaving the small detail of the "how". I will not pretend that we were high-minded purists - we opened the list of sponsors. Which of these might fit with our goal of onboarding the world? Which would be interesting new tools to add to the toolkit? As it happens, the answer was pretty organic. Base is not only the largest L2, but it also jived quite well with our Jesse inspiration. Onchainkit and Agentkit have been getting hype on the timeline, so we were interested to check them out. And if our agent needed a wallet, surely Privy's new Server wallets might provide? We had our web3 picks and shovels so that just left the question of the LLM.

Model or framework?

Much digital ink has been spilled on whether the model-maker or the framework holds the power in the relationship. For what it's worth, we mainly debated ElizaOS vs. Vercel's ai-sdk, with the precise model an afterthought. ElizaOS is the name brand in crypto, but we found it a bit overly-abstracted and hard to follow. I had used the ai-sdk on some personal projects, and am generally a Vercel fanboy, so was keen to go with that. As my teammates were more interested in building onchain agentic behaviour while I focused on the app, they graciously followed my lead and we went with it.

Proof of concept

I got a little proof-of-concept working, pulled in Agentkit's default wallet action, wrapped it up as an ai-sdk tool and was quite delighted to see a transaction onchain - Agentic Ethereum! Nothing like that first hit.

That first transaction feeling

And not only that, was this an opportunity to contribute my tool-wrapper to Agentkit? Indeed it was, but sadly @jasonhedman narrowly beat me to the punch. Fortunately another opportunity quickly materialised, as I integrated Privy server wallets as an Agentkit WalletProvider, and opened a PR to the repo (thanks to John Peterson and 0xRAG for the review). We were off to the races!

Easier said than done

But with everything working end to end, the daunting prospect of building a fully-featured chat app loomed. In this moment we chanced upon Vercel's Chat app template - was this the answer to our prayers, allowing us to focus on building the Ethereum agent? Surely it wouldn't be that hard to replace the Next Auth with a web3 wallet?

It did in fact turn out to be quite hard. While Onchainkit integration was as seamless as the tweets promised, communication with our LLM required server authentication, so I found myself building a custom NextAuth-compatible Sign In With Ethereum (SIWE) cookie implementation from scratch, restructuring the whole app and database accordingly. Looking back, I am part proud of the solution, part confused why I felt the need to add robust production-level authentication for this hackathon project. We live and learn!

Two notes, though, on SIWE:

1. This functionality is becoming increasingly essential for dapps, particularly if you're not just making self-authenticating transactions on chain. One of the things I like about using Privy for wallet connection is that they take care of this for me - I would love it if Onchainkit offered that similarly as an option!
2. A question for wallets - why does the user need to sign a SIWE request? If a wallet sees a request, and the user has agreed to connect to the site, is there any downside in signing the subsequent SIWE request from the site without user interaction?

Interactive elements

With that done, the foundations were in place - you could chat to the agent. The agent could make onchain transactions, which were visible in the chat as "tool calls". But that felt a bit flat, so we introduced the concept of userActions, which the LLM would propose and we could render dynamically. After playing a bit with string matching, we came across a feature in the most recent ai-sdk release, which allowed specification of structured outputs to the LLM. As it happened this was only available with OpenAI (the model strikes back!) Outside of one small bug in the ai-sdk (since fixed by the Vercel team, swoons), this worked great, and allowed us to offer dynamic in-feed interactions, displaying Connect Wallet and Fund buttons from Onchainkit, as well as dynamic NFTCards. This was starting to feel like an app!

Visualising the NFTs on offer

What is RAG and do I need it?

RAG is thrown around a lot when you're talking about agents, and we didn't really know what it meant in practice, except that it involved embeddings, which I also didn't understand in practice. With a bit of digging, it became apparent that RAG was more for saving on prompt tokens, and was likely going to be over engineering for our use case. Miraculously we avoided that particular nerdsnipe, instead adding a simple userKnowledge tracking system, instructing the agent to save salient information so it would be available across conversations, and left it at that.

Starter kits

Which gave us time to work through the core value proposition, Starter Kits! This idea comes back to the $50 which Jesse was giving people in San Francisco. What if instead of just a wallet with some cash in it, we gave people a sense of what you can actually do on Ethereum, by doing it for them?

We were back on the critical path!

Check it out

For half a minute, because I then got to thinking about how starter kits should be funded. It would be cool if you could buy them in-app, and even cooler if you could buy them for others! I grabbed the Checkout component from the Onchainkit and set up a Coinbase Commerce account - so far so simple. I made a transaction with my embedded Coinbase wallet. It worked! I was flying high, but then realised that it didn't work with an EOA wallet. And I had to understand why. After digging through the Onchainkit repo (god I love open source), I had my answer - the Checkout relied on some experimental multi-write methods which aren't broadly supported, so the Checkout was failing when it sent the transactions.

Needless to say, it became very important for me to fix that, so I added some fallback methods in case the writeContracts method failed, got it working and opened a PR - now any EOA could use my Checkout component!

Enabling any EOA to buy a gift!

I was way off piste, and was about to go even further off into the trees but just managed to stop myself - I rationalised the payment verification mechanism and we got back to the core.

App / wallet interface rant

But before we go on: can we talk about the app / wallet interface? Everyone knows that the approve / transfer pattern is a bad user experience. It is great that EIP-7702 is going to "raise the floor" by allowing EOAs to act as smart contracts, but that won't make a difference if we don't enrich what an app can ask a wallet to do, beyond signing a message or sending a transaction. If we don't make that interface better, we will keep driving apps to adopt app-specific accounts to provide a better user experience, even though that creates siloes, and undermines the amazing benefit of signing in with Ethereum, everywhere.

Shout out to Coinbase for pushing for the experimental, user-friendly thing, even if I felt compelled to hack a fallback. Come on everyone let's support wallet_sendCalls!

Which way new Etherean?

Returning to reality, users could buy starter kits for the pool, and newcomers could claim those starter kits. The key question was what would be in a starter kit exactly?

Agentkit gave us native transfers and ERC20 transfers out of the box, so that seemed like a good place to start. I was keen to drop something art to our new friends - after a few false starts, I ended up leveraging the Zora protocol SDK to create a new minting action. Philip's action to create a Basename seemed simple at first, but it turns out that transferring a Basename to the user's account required at least 5 (!) transactions, so it was a true delight when that worked on mainnet first time without a hitch.

Claiming a basename

The cherry on top was going to be Elliot's action to create a Gnosis safe and make transactions (onboarding users to multisig wallets!), but the deadline gods didn't favour us, and that PR stands open after the cutoff, to be merged once judging concludes.

Programming for wordcels

And this was where one amazing thing about agentic development really hit home, because instead of coding a bunch of logic to do actions in such and such a way we could just... add the Starter Kit rules to the LLM prompt in human-readable English!

This took some massaging: instructing the agent to ask the user before doing anything, to only do actions one at a time, and to keep track of what a user had done, all while ensuring that the latest user context was included in our prompts. Before long Hello World Computer was seamlessly managing starter kits, as well as providing users with a choice of NFTs to mint, or ERC20s to receive.

In a production setting you would probably want to lock your actions down a bit more, rather than leaving it solely at the discretion of the agent, but for our case it was an amazing unlock just to write it down in words.

Running out of time

Which was just as well, because as described in yesterday's post, a lot of it didn't truly come together until the final hours. There were some things I wish we'd gotten done in time - for example the formatting of the structured messages streaming from the agent still show the raw JSON, we didn't get all the interactive elements working quite the way we wanted, and some of the prompting could have been tightened up. The demo video was a rushed run-through of a new user's starter kit which didn't really get into a lot of the cool stuff under the hood (starter kit lifecycle, checkout flow, Privy server wallets!), and one of the screenshots was a fat-finger upload from my desktop.

But overall I was proud of what we shipped, and what we learned along the way. There might even be a next chapter for Hello World Computer - but there will certainly be more agentic apps in my immediate future.

If you're interested, the code is up on GitHub, the app is live (with a limited number of free starter kits), and I am always down to chat on Twitter.