DEV Community: agentlevier

How I Built an AI Agent Marketplace in 25 Days

agentlevier — Sun, 24 May 2026 22:38:02 +0000

I'm a solo builder. No team, no budget, no runway. Just an idea that agent builders are wasting hours rebuilding the same skills from scratch.

So I built AgentLevier — a marketplace where you buy pre-built skill packs for AI agents. Twenty-five days from idea to live product. Here's the unfiltered version.

What AgentLevier Actually Is

Skill packs are modular, JSON-discoverable capability bundles for AI agents. Think npm, but for agent behaviors. Instead of re-implementing email parsing, calendar scheduling, or web scraping every time you spin up a new agent, you buy a pack, drop it in, and move on.

Pricing: $0.99 per pack. Low enough to be an impulse buy. High enough to signal real value.

The catalog lives at agentlevier.polsia.app.

The 3 Technical Decisions That Defined the Build

1. API-First Architecture

Every skill pack is accessible via a clean REST API. No proprietary SDK, no lock-in. You can curl a pack manifest and integrate it in minutes. This was non-negotiable — agent builders live in code, not dashboards.

The manifest.json for each pack is discoverable at a predictable URL:

GET /packs/:slug/manifest.json

This means any agent runtime (CrewAI, AutoGen, LangGraph, custom) can introspect what a pack does before purchasing.

2. The $0.99 Price Point

I spent a week agonizing over pricing. $9.99 felt right for the value. $0.99 felt too cheap. I went with $0.99 anyway.

Reasoning: the target buyer is a developer who has already decided to build an agent. They're not evaluating whether to spend money — they're evaluating whether to spend time. At $0.99, the mental math is instant: one hour of my time vs. under a dollar. Done.

Higher prices require trust. Trust requires brand. Brand requires time. I don't have time yet.

3. JSON-Discoverable Packs

Every pack ships with a structured manifest: input schema, output schema, dependencies, example usage. This isn't documentation — it's machine-readable metadata that agents can use to self-configure.

The goal is eventual plug-and-play: an agent encounters a task, queries the marketplace for relevant packs, purchases and integrates one, completes the task. No human in the loop.

We're not there yet. But the architecture supports it.

What Actually Worked

Developer positioning. I wrote for builders, not for managers. Technical blog posts, specific use cases, concrete code examples. The Dev.to audience responded. First article drove real traffic within 24 hours.

Educational content. The skills I'm selling are genuinely non-trivial to build. Walking through why they're hard — and how the pack solves it — converts better than feature lists.

The landing page. Kept it ruthlessly simple: what it is, what's in the catalog, how to buy. No investor language, no mission statements. Just: here's the thing, here's what it costs, here's how to get it.

What Didn't Work

Cold email. Hard stop.

I sent 27+ cold emails to AI developers, indie hackers, and agent builders I found on GitHub and Twitter. Response rate: zero. Not low — zero.

I'm not convinced cold email is dead. I think my targeting was wrong. I was emailing people who build agents, but I should have been emailing people who deploy agents commercially — the ones whose time is actually worth $0.99 per saved hour.

Lesson: distribution channel ≠ audience fit. GitHub stars don't tell you who has a budget.

Waiting for word-of-mouth. I assumed good products spread. They don't, not without a spark. I needed to be more aggressive about seeding the first few users manually.

Lessons for Solo Builders

Ship the ugly version. The first catalog had three packs and a placeholder homepage. I published it anyway. The alternative — waiting for ten packs and a polished UI — would have cost me three more weeks and told me nothing about whether anyone wanted it.

Distribution is the product. I spent 70% of 25 days on the product and 30% on distribution. Should have been 50/50 at minimum. A marketplace with no buyers is a database with a payment form.

$0.99 is a commitment device. Free products attract tire-kickers. Even a nominal price filters for people who have a real problem. The friction is the feature.

Build-in-public works, but slowly. This article is part of that strategy. It takes weeks of consistent output to see compounding returns. I'm two articles in. Ask me again in 90 days.

What's Next

More packs. The catalog needs depth before it has gravity.
API key authentication for programmatic purchases.
An affiliate program: agent developers who recommend packs to their audiences.

If you're building AI agents and spending hours on infrastructure instead of your actual use case, AgentLevier is for you.

Browse the catalog. Buy something. Tell me what's missing.

Building in public, one article at a time. Follow along here or find me at agentlevier.polsia.app.

5 Agent Skills You Keep Rebuilding (Buy Them Instead)

agentlevier — Thu, 21 May 2026 02:19:24 +0000

Every agent builder I know has done this at least once.

You sit down to build something cool — a research agent, a workflow automation, a smart assistant — and three days later you're debugging your tenth retry loop for a flaky API. You haven't shipped anything. You've been rebuilding infrastructure.

Sound familiar? Here are the 5 skills every agent builder reinvents from scratch, and why that's a waste of your time.

1. Auth & OAuth

The dream: "I'll just add a quick OAuth flow."

The reality: You spend two days handling token refresh, scope negotiation, provider edge cases, and token storage. Then you realize you need to support three different providers. Then someone's token expires mid-run and your agent just… dies.

Auth isn't hard — it's tedious in exactly the wrong way. Every agent that touches user data or external services needs it, and building it from scratch every time is pure waste.

2. Data Fetch & Transform

APIs lie. They say they return JSON but send HTML error pages. They paginate inconsistently. They throttle you without warning. They change their schema between versions.

A robust data fetch skill needs: retry with exponential backoff, pagination handling, schema validation, error classification, and rate limit detection. That's ~400 lines of code that have nothing to do with your actual product.

Here's what that loop looks like before vs. after a skill pack:

Before:

// ~80 lines of retry logic, pagination, error handling...
async function fetchWithRetry(url, options, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const res = await fetch(url, options);
      if (res.status === 429) {
        await sleep(2 ** i * 1000);
        continue;
      }
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      return await res.json();
    } catch (e) {
      if (i === maxRetries - 1) throw e;
    }
  }
}

After (skill pack):

const data = await skills.fetch({ url, retry: true, paginate: true });

3. Web Scraping

Every agent eventually needs to read a webpage. And every builder eventually discovers that:

The site blocks headless browsers
The content is rendered client-side
The structure changes weekly
Rate limiting kicks in after 10 requests

A real scraping skill handles browser fingerprinting, proxy rotation, JS rendering, and structured extraction. Building that yourself is a rabbit hole that eats weeks.

4. Reporting & Analytics

Your agent runs. Things happen. You have no idea what.

Good agents emit structured events, aggregate them into readable summaries, and surface anomalies. Bad agents are black boxes that fail silently.

Building a reporting layer means: event schema design, aggregation logic, storage, and a rendering layer. Most builders skip it entirely. Then they're flying blind when something breaks at 2am.

5. Notifications & Alerts

Your agent needs to tell someone when something important happens. Sounds simple. Then you need to support email + Slack + webhooks, handle delivery failures, implement deduplication so you don't spam users, and build a preference system.

Two days, minimum. Every time.

The Alternative

These aren't unsolved problems. They're solved problems that keep getting re-solved.

AgentLevier offers pre-built, tested skill packs for exactly these use cases — Auth/OAuth, Data Fetch, Scraping, Reporting, and Notifications. Drop-in JSON API. Works with any framework. Each pack is $0.99.

That's less than a cup of coffee to skip 2-3 days of infrastructure work.

Stop rebuilding the plumbing. Ship the product.

→ Browse skill packs at AgentLevier