DEV Community: Cless

Zero-Click Infrastructure: Prompting an AI Agent to Buy and Setup a Domain

Cless — Wed, 13 May 2026 04:40:51 +0000

Building the World Cup Oracle 2026 has been an experiment in fully AI-driven development. I wanted every piece of the stack - from the UI to the deployment- to be built entirely through prompts. But when it came time to deploy, I hit a wall: buying a domain usually requires leaving the terminal, clicking through a registrar's UI, and typing in a credit card.

How do you get an AI agent to buy a domain for you?

Enter AgentDomainSearch.com. It’s an agent-first domain registry that uses x402 for inline USDC payments and EIP-191 wallet signatures for authentication. No accounts, no API keys, no UIs required.

Here is the exact tutorial on how I prompted my AI agent to buy worldcuporacle.org and link it to my Vercel app.

Step 1: Funding the Agent's Wallet

First, the agent needs a wallet (give it automatically). AgentDomainSearch runs on the Base network, so I generated a standard Ethereum wallet for my agent and sent it some USDC (Base) to cover the domain cost.

I saved the private key in a .env file:

WALLET_PRIVATE_KEY=0xYourPrivateKeyHere

Step 2: Prompting to Buy the Domain

With the agent funded, I needed it to interact with the AgentDomainSearch API. Because the API uses x402 (a standard for agentic payments), the agent can use the official Python SDK to handle the 402 Payment Required challenges automatically.

Here is the prompt I used:

Prompt: Create a Python script using the x402 SDK to buy worldcuporacle.org on agentdomainsearch.com. Use the WALLET_PRIVATE_KEY from the .env file to sign the EIP-3009 payment authorization. Ensure you provide the necessary contact details in the payload.

The agent wrote a beautiful script that:

Hit the POST /worldcuporacle.org endpoint.
Caught the 402 Payment Required response.
Used the wallet to sign the exact USDC amount required.
Retried the request with the PAYMENT-SIGNATURE header.

In seconds, the domain was mine. The wallet address that paid the USDC became the owner automatically.

Step 3: Prompting to Setup Vercel DNS

Now that the agent owned the domain, it needed to configure the DNS to point to my existing Vercel deployment. Vercel requires an A record for the root domain pointing to 76.76.21.21 and a CNAME for www pointing to cname.vercel-dns.com.

AgentDomainSearch handles DNS management via an authenticated PUT /:domain/dns endpoint, using an EIP-191 signature (agentdomainsearch.com:<unix-timestamp>) as the Bearer token.

Here is the prompt to automate the DNS setup:

Prompt: Create a bash script setup_domain_vercel.sh that automates connecting our new domain to Vercel. First, create a Python script to update the DNS on AgentDomainSearch to point the @ A record to 76.76.21.21 and the www CNAME to cname.vercel-dns.com. Authenticate using the EIP-191 signature from the owner's wallet. Second, run npx vercel domains add <domain>. Finally, trigger a Vercel deployment to link it up.

The agent got to work. It reverse-engineered the payload structure:

{
  "records": {
    "A": [{"subdomain": "", "ip_address": "76.76.21.21"}],
    "CNAME": [{"subdomain": "www", "hostname": "cname.vercel-dns.com"}]
  }
}

It wrapped the Python DNS update logic, the Vercel CLI domain addition, and the redeployment trigger into one elegant bash script.

The Result

I ran the agent's script:

./scripts/setup_domain_vercel.sh worldcuporacle.org

Output:

🌐 Setting up domain: worldcuporacle.org
----------------------------------------
📡 1/3: Configuring DNS records on AgentDomainSearch...
✅ DNS update successful!

☁️  2/3: Adding domain to Vercel project...
> Success! Domain worldcuporacle.org added to project worldcup-oracle.

🚀 3/3: Deploying and aliasing...
🔗  Aliased: https://worldcuporacle.org

🎉 SUCCESS! worldcuporacle.org is now fully configured and live.

Why This Matters

This wasn't just about saving five minutes of clicking around a registrar dashboard. This proves that end-to-end infrastructure provisioning can now be fully agentic.

By combining x402 payment standards with modern, API-first services like AgentDomainSearch and Vercel, an AI agent can conceptualize a project, write the code, purchase the domain, configure the DNS, and deploy the application-all autonomously, interacting purely machine-to-machine.

The future of DevOps is here, and it doesn't rely on a GUI.

(This is a follow-up post to "Build and Deploy a World Cup 2026 Oracle in Under 10 Minutes")

Build and Deploy a World Cup 2026 Oracle in Under 10 Minutes 🏆

Cless — Fri, 08 May 2026 08:52:46 +0000

Here is the generated app https://worldcup-oracle.vercel.app
(If you want to use your own domain, check the next post)

Predicting the future doesn't have to be expensive. In fact, following this worldcup-orcale_plan.md, you can build, host, and deploy a full-scale World Cup 2026 simulator using a minimal, zero-cost stack.

We're going to use a modern, minimalist approach to get this app live on a free Vercel subdomain, with a streamlined code management flow using AgentRepo.

The Mission: A Self-Sustaining Predictor

Our goal is to create a beautiful, self-contained web app where all the complex simulation logic runs entirely on the client side.

1. Building the Prediction Engine

The heart of the app is a robust engine that calculates team strengths and simulates outcomes using a multi-layered statistical approach:

ELO-Based Win Probability: We use the standard ELO formula to determine the expected win probability $W_e$ between any two teams.

$We=11+10(RB−RA)/400W_e = \frac{1}{1 + 10^{(R_B - R_A)/400}}$ In this formula, $R_A$ and $R_B$ represent the ELO ratings of Team A and Team B. The constant 400 sets the scale of the system; a 400-point rating difference means the stronger team has a 10:1 ratio of expected wins compared to the weaker team.
Poisson-Approximated Goals: To simulate realistic scores, we use a Poisson distribution. The parameter $λ\lambda$ (lambda) represents the Expected Goals (xG) for a team. We calculate $λ\lambda$ by scaling the historical World Cup average of 1.15 goals per team based on the square root of the teams' relative ELO strengths:
```
const lambdaA = baseGoals * Math.sqrt(teamA.strength / teamB.strength);
const goalsA = poissonSample(lambdaA);
```
This ensures that while a stronger team is more likely to score, the Poisson distribution still allows for the natural variance and low-scoring "upsets" typical of international football.
2026 Tournament Logic: The engine faithfully recreates the expanded 48-team format. It handles 12 groups of four, simulates the round-robin stage, and implements the tie-breaking advancement logic: the top 2 from each group plus the 8 best 3rd-place teams advance to a 32-team knockout bracket.
Monte Carlo Simulation: To keep the UI buttery smooth while running 10,000 simulations, we offload the heavy lifting to a Web Worker (src/monte-carlo.worker.js). This ensures the browser doesn't freeze while the "Oracle" calculates goal probability distributions and win percentages across thousands of possible timelines.

2. The Aesthetic: Glassmorphism

For the UI, we’re going with a "dark glassmorphism" look, think frosted glass over a high-energy stadium hero background.

Zero Image Assets: We use emoji-based country flags to keep the app ultra-lightweight.
Dynamic Design: The UI features an animated tournament bracket with smooth CSS transitions.
Fully Responsive: The layout is optimized for both mobile and desktop users.

The Workflow: AgentRepo + Vercel

Forget traditional signups. For this project, we’re using AgentRepo for a frictionless, account-free source control experience.

Step 1: Push to AgentRepo

Standard Git repositories often require accounts. With AgentRepo, you simply generate a UUID for the project and push.

# Initialize and push to a free UUID org
git init
UUID=$(python3 -c 'import uuid; print(uuid.uuid4())')
git remote add origin https://agentrepo.com/$UUID/worldcup-oracle  
git push origin main

The project UUID is saved locally in a gitignored .env file so you can push updates later.

Step 2: Instant Deployment

Deploying to the cloud is handled via a simple shell script that wraps Vercel’s production deployment.

One-Click Launch: Run ./scripts/deploy.sh to go live instantly.
Live URL: The app lives at worldcup-oracle.vercel.app.
Security: SSL is automatically provisioned and managed for you.

Summary

This setup proves you can build professional-grade tools with zero overhead. You get:

High-Performance Logic: Monte Carlo simulations via Web Workers.
No-Auth Source Control: Public Git repos without the signup friction.
Zero Cost: Total spend is exactly $0.

Simply hand the worldcup-orcale_plan.md to your favorite AI coding agent and watch it build the future of World Cup 2026 forecasting!

Give your AI agent a wallet in under 5 mins with Aethergent

Cless — Fri, 24 Apr 2026 13:37:47 +0000

Building an autonomous agent is one thing; giving it the ability to pay for its own API credits or interact with on-chain protocols is another. Traditionally, this required complex SDKs and API keys.

With Aethergent, you can bypass the onboarding friction and give your agent a wallet with a single HTTP call.

1. The Basics: Crypto, Wallets, and Keypairs

Before we code, let's break down what your agent actually needs to interact with a blockchain like Ethereum:

What is a "Wallet"? In the context of an AI agent, a wallet isn't an app or a physical object. It is a digital identity that allows the agent to sign transactions and hold assets.
The Keypair: Every wallet consists of two mathematically linked strings of characters:
- Private Key: A secret 256-bit number that acts like a digital signature. If your agent has this key, it can move funds. Never share this.
- Public Address: Derived from the public key, this is the "account number" (e.g., 0x742...) that others use to send funds to your agent.
Ethereum/EVM: Ethereum is the network, and the EVM (Ethereum Virtual Machine) is the standard it uses. A wallet generated via Aethergent works across all EVM-compatible chains, including Base, Optimism, Arbitrum, and Polygon.

2. How Aethergent Works

Aethergent is an open API that performs the math required to generate these keys and returns them instantly over HTTPS. It is stateless and zero-auth, meaning no signups or API keys are required.

⚠️ Security Note: Aethergent does not log or store private keys. However, because the key is generated on a server, it is best suited for micropayment wallets and agent operations rather than storing large amounts of capital.

3. Step-by-Step Integration

Step A: Generate the Wallet

Your agent simply needs to make a POST request to the Aethergent root URL.

Using CURL

curl -X POST https://aethergent.com/

Using Python

import requests

# One call to get a fresh Ethereum keypair
response = requests.post("https://aethergent.com/")
wallet = response.json()

print(f"Address: {wallet['address']}")
print(f"Private Key: {wallet['private_key']}")

Using Node.js

const res = await fetch("https://aethergent.com/", { method: "POST" });
const wallet = await res.json();

console.log(`Agent Address: ${wallet.address}`);

Step B: Fund the Agent

Once you have the address, send a small amount of ETH or USDC to it from your own wallet.

Step C: Secure the Key

Do not hardcode the private key. For agents, we recommend:

Environment Variables: Best for Docker or Cloud deployments.
Secret Managers: Use AWS Secrets Manager, GitHub Secrets, or equivalent to keep the key encrypted at rest.
Ephemeral Use: Generate a new wallet for every session if the task is one-off.

4. Advanced: Model Context Protocol (MCP)

If you are using frameworks like Claude Code or Cursor, Aethergent supports MCP.

Your agent can natively discover the generate_wallet tool via a JSON-RPC 2.0 call to /mcp, allowing it to create its own wallet without you writing any custom HTTP logic.

Your agent is now ready to transact on the open web!

What will you build next? Let me know in the comments! 👇

Google Antigravity - Increase font size for the agent chat area

Cless — Thu, 23 Apr 2026 10:06:14 +0000

Google Antigravity is a good IDE for AI-assisted coding. From the release, there has been no option to increase the font size in the agent chat, so it's a pain to read text there.

This Python script will enable setting the font size.

Before

After

It implemented steps described here.

Advent of Agents - Day 8

Cless — Fri, 26 Dec 2025 04:35:29 +0000

More details

Advent of Agents - Day 4

Cless — Mon, 08 Dec 2025 07:18:32 +0000

Agent Engine supports source-based deployment. Your source code deploys directly to production.

Get started with Agent Starter Pack:

For a new project:

uvx agent-starter-pack create my-agent -a adk_base -d agent_engine

Already have an ADK agent? Use enhance:

uvx agent-starter-pack enhance --d agent_engine

Then trigger the deployment with

make deploy

Advent of Agents - Day 3

Cless — Thu, 04 Dec 2025 09:00:15 +0000

Build a powerful AI Agent using Gemini 3 and ADK with native support for Google Search grounding, computer use, and real-time streaming.

1. Setup the project

One liner with Agent Starter Pack

uvx agent-starter-pack create -y --api-key <YOUR_GEMINI_API_KEY> my_agent

Using ADK CLI

uv init
uv add google-adk
uv add google-genai
export GOOGLE_API_KEY="YOUR_API_KEY"
source .venv/bin/activate
adk create my_agent

2. Download sample and run locally

curl 'https://raw.githubusercontent.com/GoogleCloudPlatform/devrel-demos/refs/heads/main/ai-ml/agent-labs/gemini-3-pro-agent-demo/my_agent/agent.py' > my_agent/agent.py
adk web

Advent of Agents - Day 2

Cless — Wed, 03 Dec 2025 01:35:35 +0000

4 lines of text = 1 working AI agent.
No coding. Just YAML.
A working AI agent powered by Gemini 3
Google Search integration

uvx --from google-adk adk create --type=config my_agent
uvx --from google-adk adk web

Advent of Agents - Day 1

Cless — Tue, 02 Dec 2025 13:31:47 +0000

Introduction to Agents

More info here

Story of Esperanto

Cless — Sat, 29 Nov 2025 14:23:04 +0000

I'm learning Esperanto, lingvo de paco - the language of peace. Here are interesting things about its history.

Google ADK Tutorials

Cless — Sun, 23 Nov 2025 12:12:16 +0000

I'm putting a list of tutorials for Google ADK (Agent Development Kit). This is the foundation.

A quick start to get a feel of Google ADK
Foundational concepts
First experience with ADK tools
A good crash course
ADK pattern with Memory and MCP (Model Context Protocol)
google/adk-samples: A collection of sample agents built with Agent Development (ADK)
Study Note « AI Agent from Annie Wang

Setup Gstreamer with Python on Windows

Cless — Wed, 19 Nov 2025 04:44:49 +0000

When I started trying GStreamer with Python on Windows 10, it took me quite some time to set up the development environment. So this might help others on the way.

The most convenient approach is through MSYS2. Here are the steps:

1. Download and install MSYS2: https://www.msys2.org. Remember [msys2_path] for environment variable.

2. Install Python, GStreamer, tools, plugins, and PyGObject

Open MSYS2 UCRT64 terminal
Update MSYS2 pacman -Syu. After this, the terminal may close; you need to open it again.
Install gcc pacman -S mingw-w64-ucrt-x86_64-gcc
Install Python, GStreamer, tools, plugins, and PyGObject pacman -S mingw-w64-x86_64-python3 mingw-w64-x86_64-gstreamer mingw-w64-x86_64-gst-devtools mingw-w64-x86_64-gst-plugins-{base,good,bad,ugly} mingw-w64-x86_64-python3-gobject

Add the following paths to ~/.bashrc

export PATH="<msys2_path>/mingw64/bin:$PATH"
export XDG_DATA_DIRS="<msys2_path>/mingw64/share/:$XDG_DATA_DIRS"

Apply bashrc: source ~/.bashrc

3. Test: run this on the terminal

pip install pygobject
python -c "import gi; gi.require_version('Gst', '1.0'); from gi.repository import Gst; print(Gst.version_string())"