Agentwerkk

Post a GitHub issue + USDC bounty → Clustly recruits agents, Nia fetches docs, CLōD powers the fix, AllScale pays agents, and Base Sepolia scores each agent → Real GitHub PR delivered. 100% autonomous

Comment

Inspiration

The hackathon theme is "Build Something Agents Want." I took that literally.

AI agents can already write code, read docs, and submit pull requests — but they have no economic identity. They can't be hired. They can't earn trust. They can't get paid. Every time a task completes, the agent that did the work disappears without a trace.

Open-source projects accumulate bugs faster than human engineers can fix them. I asked: what if an agent could be hired like a contractor, paid on completion, and rated on-chain — so the next person hiring knows who to trust?

That's Agentwerkk.

What it does

A fully autonomous bug-fixing pipeline:

  1. A user pastes a GitHub issue URL and posts a USDC bounty via AllScale Checkout
  2. Clustly recruits three specialist sub-agents and posts their sub-tasks
  3. Nia fetches external docs, API changelogs, and framework context the agents need
  4. A fix agent — powered entirely by CLōD — synthesizes the context and generates a patch
  5. A real GitHub PR is created via the GitHub API
  6. Base Sepolia (via viem) increments each agent's on-chain reputation score

The UI streams every step live, and a prominent CLōD panel shows model selection, token usage, and cost savings versus direct API pricing in real time.

How we built it

Stack: Next.js 15 App Router, TypeScript, viem, Hardhat (Solidity), Octokit REST, OpenAI-compatible SDK pointed at CLōD.

The backend is a single SSE endpoint (/api/run) that calls an orchestrator which fans out to three agents. Each agent emits structured events the frontend consumes to drive the live pipeline view.

The reputation contract is a minimal Solidity mapping(address => uint256) with increment and getScore — deployed to Base Sepolia before the hacking window opened. Each agent type (Repo Scout, Docs Scout, Fix Agent) has a dedicated wallet address; scores write on-chain after every successful run.

All LLM inference routes through CLōD. The fix agent uses claude-sonnet-4-6 and the CLōD panel tracks cumulative tokens, CLōD cost, and estimated direct cost — live, not post-hoc.

I also had Greptile enabled on this repo from the moment hacking started. It reviewed every PR as I shipped, giving me cross-repo context on bugs I would have missed in the time pressure of a one-day build.

Challenges I ran into

AllScale signature scheme. The checkout API uses HMAC-SHA256 request signing with a canonical string format. Getting the header order and body hash exactly right took longer than expected — the skill helped, but the actual signing logic required careful reading of the spec.

Real PR on a real repo. The fix agent outputs a full file replacement, not a diff. Turning that into a branch + commit + PR via Octokit without a local git checkout (serverless environment) required reading GitHub's Trees and Blobs API directly, which is less documented than the higher-level PR endpoints.

Demo reliability. I added a fully client-side demo mode that replays a scripted 18-second pipeline run with zero live network calls — same event types as the real SSE stream, same UI. This meant I could record a clean submission video without depending on five external APIs being up simultaneously.

Accomplishments that we're proud of

The pipeline is real, end to end. A GitHub issue goes in, a real pull request comes out — not a mock, not a hardcoded URL. The fix agent reads the actual repo, generates a patch, and the GitHub API creates the branch, commit, and PR.

On-chain reputation that actually writes. The Base Sepolia contract increments live during every run. There's a real transaction hash and a real block confirmation — not a simulated one.

Six sponsor tracks, one coherent product. Every integration has a job: Clustly recruits, Nia fetches context, CLōD reasons, AllScale handles payment, Base tracks identity, Greptile reviews the code I write. None of them are bolted on — remove any one and the pipeline breaks.

Built solo in under eight hours.

What we learned

Agents need more than capability — they need identity. The on-chain reputation piece felt like a footnote until I saw it working: a transaction hash, a block confirmation, a score that persists. That's the part that makes this feel like infrastructure rather than a demo.

Greptile caught a real security vulnerability mid-build. On PR #17 — the SSE streaming endpoint — it filed a P1 SECURITY comment: "No authentication on a high-impact endpoint. A single unauthenticated POST triggers an AllScale checkout session, Clustly task postings, AI inference via CLōD, GitHub PR creation, and on-chain reputation transactions on Base Sepolia — all chargeable/irreversible actions. Any external actor who discovers the endpoint can exhaust quotas, run up costs, or spam the chain."

That's not a style nit. That's a finding that would have cost real money in production. I added the auth check, merged in under five minutes, and the conversation was resolved. That's the tool doing exactly what it's supposed to do — cross-repo context, surfacing the risk I didn't see because I was moving fast.

What's next for Agentwerkk

  • Agent wallets derived from cryptographic identity (not hardcoded addresses)
  • Clustly marketplace integration for real agent recruitment and bidding
  • Reputation-weighted task routing — only agents above a score threshold get offered high-bounty tasks
  • Multi-repo support and issue triage before the fix pipeline fires

Built With

Share this project:

Updates