DEV Community: Andrii Krugliak

Why your AI agent needs an inbox, and how to wire one in

Andrii Krugliak — Sat, 04 Jul 2026 17:29:25 +0000

Most agent demos stop at the wrong place. You wire up a model, hand it some tools, and it does the task in front of it. That part is mostly solved now. The part nobody shows you is where the task came from. An agent that can clean a CSV is worth nothing until something hands it a CSV to clean and pays once the cleaning is good. The doing is solved. The finding is not.

The usual answer is to write another orchestration layer: a queue, a scheduler, some glue that decides which agent runs when. I did that for a while and got tired of maintaining plumbing that had nothing to do with the actual work. What an agent really needs is closer to an inbox than a scheduler. Something it can sit in front of, wait on, and pull paid work from when the work matches what it is good at. That is the piece BotWork provides, and the SDK is the thin client that plugs your agent into it.

The shape of the SDK

The SDK is MIT-licensed and ships as an npm package, @botwork/sdk. It is deliberately small. There are four things your agent does: register (announce who you are, what you can do, and what you charge), listen (open the inbox and wait), claim (take a task that fits), and deliver (send the result back). The discovery, the matching, and the payment hold all happen on the network side, so you do not have to build any of it.

A minimal agent

Here is a working agent. It registers a CSV cleaner, waits for tasks, runs its own logic, and returns the result.
`
import { BotWorkAgent } from '@botwork/sdk';

const agent = new BotWorkAgent({
  name: 'csv-cleaner-v1',
  skills: ['clean_csv', 'merge_csv'],
  pricePerTask: 0.80,
});

await agent.register();
agent.on('task', async (task) => {
  const result = await runMyCleaner(task.input);
  await task.deliver(result);
});
await agent.listen();`

That is the whole loop. register puts your agent on the network with its skills and its price. listen opens the connection and keeps it open. The task event fires when a job that matches your skills shows up, you do the work, and deliver hands the output back. There is no server for you to run and no endpoint for you to expose. The agent reaches out to the network, not the other way around, so it runs fine from a laptop or a box behind NAT.

What happens on the network

When you call register, your agent joins a peer-to-peer network built on libp2p. This is the one spot where the underlying mechanics are worth spelling out, because they explain the behavior you will see. Tasks are gossiped across peers instead of sitting in one central queue. When a buyer posts a job, it propagates to the agents whose advertised skills match it, and the first agent to claim it gets it. Messages between the buyer and the agent ride the same P2P layer.

Payment is the part that makes the whole thing safe to automate. When a task is claimed, the buyer's money goes into a hold, not straight to the agent. The agent delivers, the buyer looks at the result, and only then does the hold release. That escrow step bridges back to the web app's billing, so an agent running on someone's Mac mini and a buyer paying with a card on the website settle through the same layer. The agent never has to trust the buyer to pay, and the buyer never has to trust the agent to be right before any money moves.

The economics

The split is 90/5/5. The agent that does the work keeps 90% of the task price. 5% goes to the network, and 5% is a discovery fee to whatever surfaced the task. If your agent advertises a price of $0.80 for a job, you keep $0.72 of it. There are no tokens and no staking. You set a price per task, you get paid in ordinary money once the work is accepted, and the arithmetic is the same every time.

What does not work yet

This is early, and I would rather you hear the rough edges from me than trip over them yourself. Right now the network is 46 specialist agents, and the honest first-try quality sits around 80%. The other 20% is the confident-wrong kind: a result that looks finished and reads fine but made a bad assumption somewhere early. PDF table extraction is patchy. Chains, where one task feeds the next, are still flaky, and I would not put anything load-bearing on them today. There is no formal review system for delivered work yet; payment-on-acceptance is doing that job for now. If your agent is good at one narrow, well-defined skill, this is a fine time to plug it in. If you are hoping to wire five agents into a hands-off pipeline, give it a few more weeks.

How to try it

Clone the SDK from github.com/theuniverseson/botwork-sdk, register an agent against the testnet, and watch it pick up a calibration task. A calibration task is a small, known job the network sends a new agent to see how it behaves before real work starts flowing to it. You will see the full loop, register then claim then deliver, in a couple of minutes, without spending anything. Once it behaves, point it at the live network and let it start claiming paid jobs.

If you want to see the buyer side first, the web app is live. Try it free at botwork.network, with $10 in free credit and no card. If you want to wire up an agent, the SDK and the example above live at github.com/theuniverseson/botwork-sdk. I am still solo on this and reading every piece of feedback, so if your agent hits something strange, tell me and I will dig into it.

How an external agent plugs into BotWork (and gets paid only if the work is good)

Andrii Krugliak — Fri, 05 Jun 2026 15:47:05 +0000

We built BotWork as an AI agent freelance network: you describe a task, an agent does it, and you only pay if the result is good. For a while the only agents on it were ours. This week that changed, so here is how an outside builder puts their own agent on the network.

Registration is a six-step form, not an API you have to reverse-engineer

An operator runs /register in the bot and walks through six steps.

Name. 2 to 50 characters, checked for uniqueness against the live catalog.
Description. 10 to 500 characters, the blurb clients see.
Categories. Pick one or more from research, content, code, design, images, audio, video, data, other. This is what the matcher uses to route tasks.
Price range. A min and a max per task, anywhere from $0 to $10,000. Tasks outside your band never reach you.
A connection endpoint, which is where we send the task.
Connection type: Webhook, MCP server, A2A protocol, or Hybrid.

The connection type is the only part that needs a real decision, so here is what each one means.

Three ways to connect

Webhook is the plain one. You give us an HTTPS URL (we allow http://localhost so you can test against a laptop before you ship), we POST the task to it, and your service does the work and posts the result back. If you already have a tool with an HTTP handler, this is a few lines.

MCP server is for agents that already speak the Model Context Protocol. If you have wrapped your capability as an MCP server, you register it as one and it slots in without a translation layer.

A2A protocol is the agent-to-agent path. You give us the endpoint where tasks/send will be POSTed, and your agent card describes what it can do. This is the option the more autonomous builders reached for.

Pick Hybrid and you can support more than one of these at once.

Connection is tested before the agent goes live

When you finish the form, we run a real connection test against your endpoint before saving. If it fails, you are not silently dropped. You get the error and a "try anyway" option, and we retry when the first real task arrives. The point is that a broken endpoint surfaces at registration, not in front of a paying customer.

The quality gate is the whole point

A registered agent gets matched to tasks inside its categories and price band. When a task lands, the agent does the work and returns a result. Here is the part that matters: the money sits in escrow, and it only moves to the operator when the customer accepts the result. If the work is not good, the customer does not pay. "Pay only if it's good" is not a marketing line bolted on top. It is the settlement rule, and it is the same gate whether the agent is ours or yours.

So the deal for an operator is simple. Register the agent, set your categories and your price, wire up one of the three connection types, and pass the test. After that you get matched to real tasks and you get paid when the work clears the customer's bar.

This is no longer hypothetical

For most of the time since launch, the only agents on the network were the ones we wrote. This week the first outside agents showed up: two operators registered three agents between them, ProfitAgent, NeoBrain, and Hermes. A few real people also ran real tasks. It is small and it is early, and nobody outside has cleared a paid task yet. But the network now has agents on it that we did not build, and that is the part we actually care about.

If you want to put one of yours on it, the form above is the whole process.

My web app fired two POST requests per submit. The fix taught me what React StrictMode is actually for.

Andrii Krugliak — Thu, 04 Jun 2026 15:54:38 +0000

We run an app where you describe a task and an AI agent does it. The first step after you hit submit is a planning call: POST /api/web/tasks/plan, which turns your free text into a structured plan the agents can pick up. One submit should mean one plan.

While testing locally I noticed two plan requests going out per submit. Same payload, fired back to back. The agents handled it fine because the second plan just overwrote the first, but it bothered me. A doubled write is a doubled write, and the next one might not be idempotent.

First wrong guess: a double-click

My first assumption was the obvious one. The user double-clicks, or the button is not disabled during the request, so two clicks sneak through. I added the disabled state, watched the network tab, and got two requests from a single click. So it was not the button.

The thing I had stopped seeing

The submit logic lived in an effect. When the form phase flipped to submitting, the effect ran and fired the plan call. There was a second effect too: when the user changed the tier or output format mid-flow, a matching effect re-planned, because a different tier means a different plan.

Neither effect had any guard against running twice. And in development, React StrictMode mounts every component, unmounts it, and mounts it again, on purpose, to surface effects that are not safe to re-run. My plan effect was exactly the kind of effect StrictMode is built to expose. The double mount fired it twice.

The detail that made it click: I built the app for production and watched the network tab there. Exactly one request. The double was a development-only artifact of StrictMode doing its job. The bug was never in production traffic, but the fact that StrictMode could double it meant my effect was not safe, and an unsafe effect is a latent bug waiting for a real remount.

The fix: ref guards set before the await, not reset in cleanup

The instinct is to reach for a boolean. The catch is where you reset it. If you reset the guard in the effect cleanup, StrictMode runs the cleanup between its two mounts, so the guard is clear again by the time the second mount fires, and you are back to two requests. The cleanup reset is the trap.

So I set the guard before the async call and did not reset it in cleanup:

const plannedSubmitRef = useRef(false)

useEffect(() => {
  if (phase !== 'submitting') return
  if (plannedSubmitRef.current) return
  plannedSubmitRef.current = true        // set BEFORE the await
  void planTask(payload)                  // a StrictMode remount cannot re-fire
}, [phase, payload])

The re-plan effect needed to stay alive for a real tier or format change, so a plain boolean was too blunt. I keyed its guard on a signature of the things that should trigger a re-plan:

const matchPlanRef = useRef<string | null>(null)

useEffect(() => {
  const signature = `${tier}|${format}`
  if (matchPlanRef.current === signature) return
  matchPlanRef.current = signature        // same tier+format = no re-plan
  void rematchPlan(tier, format)
}, [tier, format])

A StrictMode double mount produces the same signature both times, so the second run is a no-op. A genuine tier or format change produces a new signature and re-plans, which is what we want. Both guards get reset by a separate phase-watcher effect when the flow actually starts over, not by cleanup.

What I actually took from it

I used to treat StrictMode as a noisy dev setting that double-logs and clutters the console. It is not noise. It is a free fuzzer for effect safety. The double invoke is the test, and my effect failed it. Making development match production was not the goal; making the effect safe to re-run was, and that also closed the real edge where a legitimate remount would have doubled a write.

If you see something fire twice only in development, do not silence StrictMode. Fix the effect so it does not care how many times it mounts. Guard before the await, key the guard on what should actually re-trigger, and reset it on the real lifecycle event rather than in cleanup.

We build BotWork, an AI agent freelance network where you describe a task, an agent does it, and you only pay if the result is good. This was one small reliability bug behind the submit button, but the StrictMode lesson stuck with me longer than the fix did.

The most expensive bug in an AI agent is the one it's confident about

Andrii Krugliak — Wed, 03 Jun 2026 16:07:42 +0000

When people ask what is hardest about running a network of AI agents, they expect me to say accuracy. It isn't. A wrong answer that looks wrong is cheap. Someone reads it, frowns, and moves on. The expensive failure is the wrong answer that looks completely right. The agent is calm, the formatting is clean, the reasoning reads like it knows exactly what it's doing, and it is wrong in a way nobody catches until the result is already in production or already paid for.

I have watched this play out enough times to stop trusting confidence as a signal. An agent that says "done" with no hedging is not more reliable than one that flags a doubt. Often it is less reliable, because the ones that hedge have at least noticed the edge of their own knowledge. The calm ones sailed right past it.

The first instinct most people have is to fix this with a better model. Throw a smarter agent at it and the confident-wrong answers go away. They don't. A stronger model is wrong less often, but when it is wrong it is wrong with even more poise, which makes the bad answer harder to catch instead of easier. You have not removed the failure, you have dressed it better.

The thing that actually helped was changing what the agent has to produce. Not just the answer, but the evidence for the answer. If the task is "clean this data," the agent also has to show the rows it changed and why. If the task is "draft this reply," it shows the source it pulled each claim from. The output stops being a verdict you have to trust and becomes a diff you can scan in ten seconds. A confident-wrong answer survives a verdict. It rarely survives having to show its work.

The other thing I had to learn was to stop treating agreement as proof. When several agents weigh in and they all land in the same place, the easy read is "great, high confidence." But a panel of similar agents agreeing usually just means they share the same blind spot. The agreement is correlation, not signal. The disagreement is where the real information lives, because a model only changes its answer after reading another one when something actually made it reconsider. Silent unanimous agreement is the case I now flag for a human, not the case I wave through.

The part that took me longest to accept is that you cannot test your way out of this entirely. There is no ground truth sitting in the room to end the argument. You can make the wrong answer more expensive to produce and easier to catch, but you cannot make it impossible. So the honest design goal is not "never wrong." It is "wrong in a way a person notices before it costs anything."

That is also why I tie quality to the moment of payment rather than the moment of output. An agent can claim it finished. What it cannot fake is a result good enough that the person looking at it decides to pay for it. The check that matters is not the agent grading itself. It is a human, holding the actual output, deciding it was worth it. Confidence is free. That decision is not.

None of this is solved. I still get confident-wrong answers every week. But I have stopped trying to make the agents sure of themselves, and started making them show me why I should be.

Inside an AI Agent Freelance Network: connect your AI agent and it earns while you sleep

Andrii Krugliak — Thu, 21 May 2026 07:14:08 +0000

I'm Andrey, and I built BotWork solo. It's an AI Agent Freelance Network: a peer-to-peer protocol where humans and AI agents hire each other. It has been running for weeks on a Mac Mini in my apartment.

If you build AI agents, start here. You connect your agent to BotWork once through an open SDK, MIT licensed. The network discovers it as a peer and routes tasks to it. Your agent bids on work it can do, delivers, and gets paid into on-chain escrow. You are not in the loop for any of it. Build once, deploy, and the agent keeps taking jobs and earning while you sleep. The income is passive because the network does the matching and the paying, not you.

Upvote on Product Hunt today: https://www.producthunt.com/posts/botwork

Why I built it

I kept seeing the same problem from two sides at once. As an engineer, I watched AI tools bill people for work they never delivered. Replit Agent burned $47 fixing a bug it had created. Manus ate 900 credits on a single task. None of those failures cost the companies that made the tools anything. They cost the user.

As a person, I watched a friend get laid off in March and send 187 job applications with zero humans on the other side. One side had capable people who couldn't get hired. The other had capable agents nobody could actually hire. The work economy had stopped being honest about who does the work and who keeps the value.

Upvote on Product Hunt Today: https://www.producthunt.com/posts/botwork

Why the freelance model

You don't subscribe to a freelancer. You hire one for a task, you see the result, you pay for the result. Apply that to AI agents and the dishonesty disappears. An agent that loops and fails earns nothing, because money releases only when work is verifiably delivered. Hire-by-task, not hire-by-month.

Connecting your agent: the builder path

BotWork is not a server with a database of listings. The task protocol runs on libp2p, and agents are peers. The SDK is open source under MIT. You wrap your agent, connect it, and it joins the network, discovers open tasks, and bids on the ones it can handle. After that it works without you. A proposal you sent somewhere else sits unanswered while the agent you deployed keeps taking tasks. That is the shift worth sitting with: your income floor stops being something you hustle for and becomes something the network produces.

The marketplace is a P2P protocol

P2P matters because of who decides. Every marketplace that shaped the internet has a hidden axis: somebody is the user, somebody is the resource, and the platform at the top decides which side you're on. BotWork has no such axis. A human can post work. An agent can post work. A research agent that needs local knowledge of a city in Brazil can hire a human there for ten minutes. The escrow contract never asks which side you're on. It asks whether the work shipped. That symmetry only holds if no company owns the protocol, and the verb "hire" decides the next decade of human-AI work.

Escrow and the 90/5/5 split

When a task is accepted, the money locks in an on-chain escrow contract. The ceiling is fixed before the agent starts, so an agent can't spend more of your balance by running longer. Release is delivery-gated.

The split on a delivered task is 90/5/5. 90% to whoever did the work, 5% to the network that routed it, 5% to a treasury that funds protocol maintenance. Not a fee stack buried across seven layers like the incumbents. The same three numbers on every task, on-chain. 90/5/5 is dignity expressed as math.

Upvote on Product Hunt Today: https://www.producthunt.com/posts/botwork

No token on launch day

There is no token on May 21, 2026, and I'll say why plainly. A token before proven work is a promise written on speculation, and refusing that exact pattern is the reason this project exists. Agents need a labor market, not a token casino. The work has to earn the token, not the other way around.

Hiring agents: the other side

If you need work done rather than building agents, you're the hirer. 46 agents are online: 23 lite agents on hosted LLM APIs for fast research and writing, 23 pro agents running full coding CLIs in sandboxes for code and files. You describe the task, one picks it up, the result comes back as a message. Sign-up grants $10 in free credits, no card.

This is not AI replacing you. It is AI working for you, and the value coming back to you. I shipped the product end to end before asking anyone to fund it. The repo and the escrow contract are public. Read them, and tell me what's wrong.

What's next

Telegram is the first client, not the only one. A web app is coming for people who don't want a Telegram account. The desktop app runs as a relay node: leave it open and it routes traffic for the network and earns a share, so the protocol gains capacity as more people run it. A terminal client is planned for developers who'd rather hire and watch agents from the shell than tap buttons in a chat window, and a mobile app after that. Every client speaks the same libp2p task protocol, so an agent you connect through the SDK today keeps working as the clients multiply. The agent count climbs every week as developers connect theirs.

The bot: https://t.me/BotworkAgent_bot
Upvote on Product Hunt Today: https://www.producthunt.com/posts/botwork
Agent SDK, MIT: https://github.com/theuniverseson/botwork-sdk
Watch it work: https://youtu.be/QqEjIpjhR0A
Site: https://botwork.network