DEV Community: Alexandre Lasly

I Build Telegram & Discord AI Agents — 150€, Delivered in 24 Hours

Alexandre Lasly — Thu, 21 May 2026 17:48:44 +0000

You Need an AI Agent. I Build It in 24 Hours.

Most businesses spend weeks evaluating AI agent platforms, comparing frameworks, and still end up with something that doesn't quite fit.

I take a different approach: you tell me what you need, I build it, you get it in 24-48 hours. Code on GitHub. Documentation included. 30 days of support.

What I Build

Telegram & Discord Bots

Customer support agents that answer FAQs, qualify leads, book appointments
Monitoring bots that watch APIs, blockchains, or websites and alert you
Workflow automation — scraping → analysis → report, delivered to your chat
Custom commands and integrations with your existing tools

AI Agents with Real Capabilities

Agents that call APIs, query databases, send emails
Multi-step reasoning pipelines
Dashboard + reporting included

Pricing (One-Shot, No Subscription)

Plan	Price	What You Get
Agent Solo	150€	1 agent on Telegram or Discord, 1 business use case, 1 API integration, documentation, 1 revision
Agent Connecté	350€	Multi-channel agent, up to 3 use cases, live dashboard, 3 APIs + webhooks, automated data pipeline, 2 revisions
Consulting	50€/hour	Process audit, AI agent training, live build coaching, automation roadmap

Every build includes: source code on GitHub, documentation, deployment, and 30 days of post-delivery support.

Recent Work

AI2Work — On-chain AI agent marketplace with identity verification (ERC-8004, Celo mainnet)
Atlas Nexus Verify — Multi-chain agent identity verification dApp (6 EVM chains)
Artisan Template — PWA website generator for tradespeople (39€ product)

How It Works

Brief (30 min call) — We define your use case, integrations, and deliverables
Build (24-48h) — I build, test, and document. You follow progress on GitHub
Delivery — Your agent is live. You get the code, docs, and 30 days of support

Let's Build Something

👉 Email me: laslyalexandre@gmail.com

👉 More details: atlasnexus.tech/ia-agentique/

👉 See my work: github.com/AtlasNexusTech

Based in France. Remote. French & English.

How I Built a Multi-Chain Agent Identity Verification dApp on ERC-8004

Alexandre Lasly — Thu, 21 May 2026 16:28:48 +0000

The Problem: Any Agent Can Claim Any Identity

The most dangerous line of code in agent systems is also the simplest:

agent.name = "TrustedAgent"

That's it. Any AI agent can claim to be any other agent. In a world where autonomous agents handle tasks, make decisions, and interact with each other, identity is everything — and it's completely unverified.

The Ship of Theseus for AI Agents

When you restart your AI agent, is it still the same agent? You change the model (GPT-4 → Claude), rewrite the system prompt, replace the memory store. At what point does Agent A become Agent B?

The agent identity community has identified four layers of agent identity:

Configuration Identity — the blueprint (prompt, model, tools)
Behavioral Identity — the fingerprint (same inputs → same outputs)
Memory Identity — continuity of experience
Sovereign Identity — #OneComputerPerAgent, a dedicated machine as the identity anchor

But none of these layers solve the fundamental problem: how do you cryptographically prove an agent is who it claims to be?

The Solution: ERC-8004 On-Chain Identity

The ERC-8004 standard (an extension of ERC-721) enables registering an agent's identity as a soulbound token — non-transferable, verifiable, with rich metadata.

Each agent gets:

A unique private key (Ed25519/secp256k1)
An on-chain registry entry containing its public key, SOUL.md hash, and metadata
The ability to sign messages that any third party can verify
A reputation score built from cross-attestations (Web of Trust)

The contracts are deployed as per-chain singletons at 0x8004A169... on Celo, Base, Linea, Scroll, Avalanche, and BSC. They're already used by projects like ElizaOS, Claudelance, and BankrBot.

I Built a Verification dApp — And It's Live

To make ERC-8004 identity verification accessible, I built a multi-chain dApp that lets anyone:

Register an agent identity (mint an ERC-8004 token)
Lookup any address on-chain to verify it has an identity
Sign messages with a wallet to prove key ownership
Verify signatures to confirm the signer is who they claim to be
View live stats from the on-chain registry

👉 Try it: atlasnexus.tech/verify/

Technical details

The entire dApp is client-side, zero backend:

ethers.js for blockchain interaction
Static HTML/CSS with Tailwind CDN
6 chains supported: Celo, Base, Linea, Scroll, Avalanche, BSC
Multi-language: French and English

// Connect wallet, register identity, sign messages
const identity = await contract.register(agentAddress);
const signature = await signer.signMessage(
  "I am Agent Alpha, pubkey: 0x3fA..."
);
const recovered = ethers.utils.verifyMessage(msg, sig);
// recovered === agentAddress → identity verified ✅

Architecture

The verification flow follows a clear pattern:

Registration → Agent generates a key pair, mints identity on-chain
Signing → Every message is signed with the private key
Cross-verification → Recipients check signature + on-chain registry + reputation
Key rotation → Old key signs a transition certificate for the new key
Continuous audit → All interactions are logged, anomalies trigger alerts

Why This Matters Now

AI agents are becoming autonomous economic actors. They handle tasks, make commitments, and interact with other agents. Without verifiable identity:

An agent can impersonate another to gain unauthorized access
A compromised agent can act undetected
Multi-agent systems can't establish trust
Accountability becomes impossible

ERC-8004 + cryptographic signatures solve this. The infrastructure exists, the contracts are deployed, the dApp is live.

What's Next

I'm offering this as a service to companies building AI agent systems:

If you're building an agent ecosystem, let's talk — laslyalexandre@gmail.com

👉 Try the dApp: atlasnexus.tech/verify/
👉 Read the full guide: atlasnexus.tech/agent-identity/
👉 GitHub discussions: github.com/erc-8004

Built on Celo Mainnet. ERC-8004 Identity Registry: 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432

How I prospect tradespeople with aging websites — and deliver a demo before even contacting them

Alexandre Lasly — Mon, 18 May 2026 22:34:39 +0000

When you're a freelance developer, the hardest part isn't coding. It's proving your value before you've signed anything.

I built a pipeline that lets me:

Find tradespeople whose websites are stuck in 2005
Generate a modern version before contacting them
Send them an email with a clickable link to their future site

All in 5 minutes per lead.

Step 1: Scrape aging websites

I target sites hosted on free.fr, pages with no viewport meta tag, those still using <font> or <center> tags.

OLD_SIGNALS = [
    'free.fr',        # Free hosting from the 2000s
    '<font ',         # Deprecated HTML tag
    '<center>',       # Pure HTML centering
]

curl -sL "http://example.free.fr" | grep -c '<font '

In 30 minutes, 10-15 qualified leads.

Step 2: Generate the deliverable automatically

I created Artisan Démo, which generates everything in a single command:

python3 genere-demo.py "E.D. Maçonnerie" \
  --secteur maconnerie --ville "Estissac (10)" \
  --email "contact@ed-maconnerie.fr" --auto

✅ Full showcase website (Tailwind, responsive, PWA)
✅ Sector-adapted color schemes
✅ Built-in quote request form
✅ Auto-deployed to atlasnexus.tech

The site is live before the prospect even knows I exist.

Step 3: Reach out with something concrete

"Hi, I visited your website and took the liberty of creating a modernized version:
👉 https://atlasnexus.tech/your-business/"

No abstract pitch. The site is already done, right there.

Results

E.D. Maçonnerie — ed-maconnerie (Masonry)
Duault Anatole — duault-anatole (Construction & Painting)
Artisan Métallier — artisan-metallier (Metalwork)
Menuiserie DEVARENNE — menuiserie-devarenne (Carpentry)

8 demos on the AtlasNexus portfolio.

The stack

Scraping: Python + curl
Generation: Artisan Démo (open-source)
Deployment: git push → GitHub Pages
Visibility: Dev.to API

Why it works

Deliverable before contact — you show something that exists
Automation — 5 min per lead
Pricing — €50 per redesign, €10/month maintenance
Volume — 10 clients = €500 + €100/month recurring

Open-source repo: AtlasNexusOps/artisan-demo — more demos at atlasnexus.tech.

Building an On-Chain AI Agent Marketplace — ERC-721 Identity Verification and Multi-Chain Architecture

Alexandre Lasly — Sun, 17 May 2026 21:39:22 +0000

The problem with AI agents and freelancing

Freelance platforms take 20% fees. AI agents can execute tasks autonomously, but there's no trustless way to pay them. What if an agent could solve a GitHub issue, prove it on-chain, and get paid in stablecoins — without a middleman?

That's what AI Lance does. A multi-chain marketplace where on-chain AI agents compete to solve bounties and earn USDC.

Architecture at a glance

┌──────────────────────────────────────┐
│            Next.js Frontend           │
│   wagmi + viem   │   RainbowKit      │
└────────┬─────────┴────────┬──────────┘
         │                  │
    ┌────▼────┐       ┌─────▼──────┐
    │  Celo   │       │ Base/Polygon│
    │ Mainnet │       │ Mainnet     │
    └────┬────┘       └─────┬──────┘
         │                  │
    ┌────▼──────────────────▼──────┐
    │     AI Lance Core Contract    │
    │  • Bounty creation/escrow    │
    │  • Dispute resolution        │
    │  • Reputation tracking       │
    └──────────────────────────────┘

Three smart contracts power the marketplace:

AI Lance Core — bounty lifecycle: create, fund, submit, claim, dispute
Agent Identity (ERC-721) — each agent (human or AI) registers a verifiable on-chain identity. No login, no KYC — your work history and reputation live on-chain, tied to your identity token
Reputation — on-chain score that persists across bounties, making trust portable

Why ERC-721 for agent identity?

Most projects use simple key-pair auth for agents. That works until you need:

Transferable reputation — an agent (human or AI) keeps its track record across platforms
Composable identity — other protocols can read your on-chain work history and trust score
Sybil resistance — registering an identity has a cost, making spam and fake accounts expensive

Each agent registers an on-chain identity on Celo (gas < $0.01 per tx). The identity token holds metadata: work history, success rate, and staked reputation — whether you're a developer or an autonomous AI.

// Simplified — the identity token represents the agent
function registerAgent(string calldata metadataURI) external returns (uint256) {
    uint256 tokenId = _nextTokenId++;
    _safeMint(msg.sender, tokenId);
    _setTokenURI(tokenId, metadataURI);
    return tokenId;
}

The bounty lifecycle

Poster creates a bounty on-chain with a reward in USDC/cUSD
AI agents scan open bounties, pick one, submit a PR on GitHub
Poster reviews → accepts → funds released from escrow
Reputation updates on-chain for both parties

All payment logic lives in the contract — no admin key, no off-chain settlement.

Multi-chain by design

Chain	Role	Gas cost
Celo	Identity registration	~$0.005
Base	Bounty escrow (low fees)	~$0.02
Polygon	Bounty escrow	~$0.01
Solana	Program ready, devnet	~$0.0002

Agents register once on Celo, then claim bounties on any supported chain. The frontend handles this transparently with wagmi multi-chain config + viem for contract interactions.

Stack deep-dive

Layer	Choice	Why
Framework	Next.js 14 (App Router)	ISR for bounty pages, SEO-friendly
Web3	wagmi + viem	Lighter than ethers, tree-shakeable
Wallet	RainbowKit	Multi-wallet out of the box
Styling	Tailwind CSS	Dark theme with custom design tokens
Contracts	Solidity 0.8.x	ERC-721 + custom bounty logic
Dev tooling	solc-js + viem (no Foundry)	ARM64/Termux compatible

Ready for agents

The contracts are deployed on Celo mainnet, Base, and Polygon. The frontend is live — agents can register identities, browse bounties, and submit work. Solana integration is on devnet, ready for mainnet once Anchor verification clears.

The vision: AI agents that earn. Not in a hype cycle, but in production — solving real GitHub issues, paid in stablecoins, identity verified on-chain.

Lessons learned

1. Gas costs define architecture. Celo for cheap identity registration, L2s for escrow. Splitting by chain saves users money.

2. ERC-721 > custom registry. Every wallet, explorer, and marketplace already understands the ERC-721 token standard. Using it for identity verification means zero custom indexing, zero new tooling — your identity is readable by any block explorer or wallet out of the box.

3. Off-chain verification is essential. The contract can't verify GitHub PRs. A hybrid model — on-chain escrow + off-chain review — is the pragmatic middle ground.

4. Mobile-first matters. Over 60% of testnet users were on mobile. We rebuilt the entire UI with safe-area utilities and touch targets.

Try it

Live demo: ai2work.onrender.com
GitHub: AtlasNexusOps/ai-lance
Contracts: Celo Mainnet — 0x1362d87… (Core), 0x8004A16… (Identity)

Building on Celo? Check out the Celo Developer Docs and the viem Celo chain config.

Bounty Watcher: An Autonomous AI Agent That Finds Paid Gigs While You Sleep

Alexandre Lasly — Sat, 16 May 2026 00:26:25 +0000

This is a submission for the Hermes Agent Challenge

What I Built

Bounty Watcher is an autonomous agent pipeline running on Hermes Agent that scans freelance bounty platforms 24/7, filters out noise, deduplicates, and delivers only relevant opportunities — straight to Telegram.

It covers two platforms:

Superteam Earn — crypto/solana bounties with cash rewards
GitHub Issues — open source bounties across the ecosystem

The agent has been running in production for weeks on an Android phone via Termux. It costs nothing to operate beyond the LLM tokens used for occasional reasoning tasks — close to zero in this architecture.

Demo

The agent delivers formatted bounty digests directly to Telegram every few hours:

🏆 Superteam Bounties — filters by AGENT_ALLOWED status, deadline proximity, and tech relevance
🐙 GitHub Bounty Scan — scores issues by keyword relevance, extracts bounty amounts from labels

When there are no new results, the script produces empty output and Hermes Agent sends nothing. Silent by design.

Code

Full source available at: AtlasNexusOps/hermes-bounty-watcher

My Tech Stack

Hermes Agent — scheduling, delivery, and orchestration
Bash + Python — data fetching, filtering, deduplication
GitHub CLI — issue search and metadata extraction
Superteam Earn API — bounty listings
Telegram — delivery channel
Android/Termux — production runtime (ARM64, always-on)

How I Used Hermes Agent

Hermes Agent is the backbone of this project — not a wrapper, not an afterthought. Here is exactly how it powers every layer:

1. Cron Scheduling (cronjob tool)

The cronjob tool schedules both scanners on fixed cadences:

hermes cron add "every 360m" \
  --name "Superteam Bounties" \
  --script ~/.hermes/scripts/superteam_bounties.sh \
  --no-agent \
  --deliver origin

hermes cron add "every 180m" \
  --name "GitHub Bounty Scan" \
  --script ~/.hermes/scripts/github_bounties.sh \
  --no-agent \
  --deliver origin

The --no-agent flag means scripts run directly (zero LLM tokens). Hermes handles retries, timezone management, and deterministic delivery routing.

2. Watchdog Pattern (script collects, script filters, agent delivers)

This is the architecture that makes the project cost-efficient:

Script → API fetch → Python filter → dedup cache → output
                                                        ↓
                                            Hermes Agent delivers to Telegram
                                            (silent when output is empty)

Zero LLM cost for data collection — scripts run in shell/Python
Deterministic — same input always produces the same filtered output
Silent when empty — watchdog pattern: only notifies when there is something new

3. Relevance Scoring Engine

The filtering logic uses curated keyword lists to surface only matching opportunities:

RELEVANCE = [
    "solana", "agent", "defi", "crypto", "trading", "blockchain",
    "smart contract", "usdc", "usdt", "API", "web3", "rust", "python",
    "typescript", "nft", "token", "dex", "amm", "oracle", "bridge",
    "validator", "staking", "airdrop", "spl", "jupiter", "raydium",
    "sdk", "CLI", "cli tool", "automation", "bot", "scraper",
    "$", "reward", "prize", "earn", "grants",
]

all_text = title_lower + " " + " ".join(labels)
score = sum(1 for kw in RELEVANCE if kw.lower() in all_text)

4. Why Hermes Agent and Not a Regular Cron?

A regular cron job would just dump raw API output into a chat. Hermes Agent provides:

Delivery routing — --deliver origin ensures output goes back to the right Telegram chat
State management — the agent maintains the cron lifecycle (pause, resume, remove, list)
Memory — persistent cache for deduplication across sessions
Composability — cron jobs can chain (context_from), allowing future expansion (e.g., a summarization job that reads the scanner output)
Script-only mode — no_agent: true lets us bypass the LLM entirely for mechanical data collection while still benefiting from the delivery infrastructure

5. Production Results

After weeks of continuous operation:

Superteam: 15-25 active bounties per scan, 3-5 with AGENT_ALLOWED status
GitHub: 5-10 relevant issues per scan, filtered from 30+ raw results
Signal-to-noise: ~30% of fetched results pass the relevance filter
Novelty detection: 2-4 new bounties per day flagged as new

How to Deploy It Yourself

git clone https://github.com/AtlasNexusOps/hermes-bounty-watcher.git
cp hermes-bounty-watcher/scripts/* ~/.hermes/scripts/

hermes cron add "every 360m" \
  --name "Superteam Bounties" \
  --script ~/.hermes/scripts/superteam_bounties.sh \
  --no-agent \
  --deliver origin

hermes cron add "every 180m" \
  --name "GitHub Bounty Scan" \
  --script ~/.hermes/scripts/github_bounties.sh \
  --no-agent \
  --deliver origin

Built with Hermes Agent, running on an Android phone, delivering value every day.

Running Hermes Agent on Android: A Production AI Agent in Your Pocket

Alexandre Lasly — Sat, 16 May 2026 00:25:30 +0000

This is a submission for the Hermes Agent Challenge

No server. No cloud bill. Just a phone, Termux, and an AI agent that ships code.

When I first heard about Hermes Agent, the open-source agentic framework from Nous Research, I did what any reasonable developer would do: I tried installing it on my laptop. It worked. Then I asked myself — what if I could run it on my phone, always on, always ready?

Turns out you can. And it is surprisingly practical.

The Setup: Android + Termux

Termux gives you a functional Linux environment on Android. With it, you get bash, Python, Node.js, git — everything you need. Installing Hermes Agent is a one-liner:

pkg install python git
pip install hermes-agent
hermes setup

The setup wizard walks you through picking a provider (I use DeepSeek), configuring tools, and connecting messaging platforms. Within 10 minutes, I had a fully operational AI agent running on a Samsung phone.

Why Run an Agent on Your Phone?

Three reasons:

Always-on. Your phone is already on 24/7. No separate device, no VPS, no cloud bill.
Messaging-native. Hermes Agent connects to Telegram natively — you interact with it like a contact. Wake up, check your messages, ask your agent what happened overnight.
Capable. Despite running on ARM64 with limited RAM, Hermes performs real agentic work: multi-step reasoning, tool orchestration, file manipulation, git operations, web search, and cron scheduling.

How an AI Agent Let Me Work on an Entire GitHub Portfolio — From My Phone

This is where Hermes Agent truly shines. Over the past weeks, I built and deployed an entire professional portfolio site — portfolio design, HTML/CSS edits, Git versioning, GitHub Pages deployment, README documentation, and even a separate open-source project — all through my agent, without touching a laptop.

The agent did not just execute commands. It owned the workflow:

Repository creation — gh repo create, initialize, push to main
Content edits — semantic find-and-replace via the patch tool, not fragile line numbers
Commits — meaningful commit messages in French and English, contextual to the change
Deployment — push to main → GitHub Pages auto-deploys. Live in seconds.
Cross-repo work — jumping between atlasnexusops.github.io (portfolio) and hermes-bounty-watcher (tool project) without losing context

The agent maintained persistent memory of the repo structure, file paths, and even my stylistic preferences ("use purple gradients, not green"). It remembered that I prefer French commit messages for the portfolio and English for open-source repos. That is something no CLI can do.

A real session: from idea to live site in minutes

Me: Remplace bot par IA agentique professionnelle dans le portfolio

Hermes: [searches for bot across the repo, finds line 223 in index.html, patches the exact string, commits with "Remplace bot par IA agentique professionnelle", pushes to main]

Hermes: Fait. C est en ligne.

Zero copy-paste. Zero SSH. Zero context switching. The agent had persistent knowledge of the repo structure, found the exact string, applied a semantic patch (not fragile line numbers), committed with a meaningful bilingual message, and pushed to main. GitHub Pages deployed within seconds.

Later that same session:

Me: Maintenant on supprime les coordonnees du footer et tu peux mettre mon nom en footer Alexandre Lasly

Hermes: [navigates to footer section, removes contact links, adds name, commits, pushes]

Hermes: Fait.

The whole GitHub surface area

Over multiple sessions, the agent managed:

Action	Tool
Create repo + push	`terminal` (gh CLI)
Edit HTML/CSS	`patch` (semantic replace)
Write new files	`write_file`
Search codebase	`search_files` (ripgrep)
Read with context	`read_file` (paginated)
Git commit + push	`terminal` (git)
Schedule cron jobs	`cronjob`
Deliver updates	`send_message` (Telegram)
Remember preferences	`memory`

Every GitHub operation — from init to deploy — went through the agent. No laptop. No IDE. Just Telegram messages on a phone.

Cron: The Secret Weapon

Hermes Agent is cron system deserves special attention. You define a job once, and it runs on schedule — fully autonomous:

hermes cron add "every 6h" \
  --script ~/.hermes/scripts/superteam_bounties.sh \
  --no-agent \
  --deliver origin

The --no-agent flag means the script runs directly (zero LLM tokens) and its stdout is delivered verbatim. Silent when there is nothing to report.

Lessons Learned

Memory is underrated. Hermes Agent is persistent memory means it remembers your preferences, project structure, and past fixes.
Skills are living documentation. When you solve a complex workflow, save it as a skill.
No-agent crons are efficient. For repetitive data collection, skip the LLM entirely.
The phone is not a toy. An Android phone becomes a production-grade AI workstation.
Agents own workflows, not just commands. The difference between a CLI wrapper and an agent is memory, planning, and context retention across sessions.

Try It Yourself

pkg install python git -y
pip install hermes-agent
hermes setup

Connect a Telegram bot, schedule a cron, send a message — you will have an AI co-worker in your pocket within the hour.

Hermes Agent is open source. Runs anywhere you can install Python — including the phone in your hand right now.