DEV Community: Ayantik Sarkar

AI Agents Can Do the Work. But Who Manages the Workforce?

Ayantik Sarkar — Mon, 19 Oct 2026 07:42:08 +0000

We've reached a point where AI agents can write code, research competitors, analyze data, and generate reports.

But there's a problem that becomes harder as the number of agents grows.

Who decides which agent should do the job? How much should it cost? Who checks whether the result is actually good?

Getting an agent to complete a task is one problem. Reliably coordinating multiple agents is another.

That's the problem we've been exploring with Threadpool.

The problem with simply connecting agents

Imagine asking an AI system to conduct a competitive analysis.

The task might involve researching competitors, collecting pricing data, comparing features, analyzing the market, and preparing a final report.

You could build a workflow that calls five different agents in sequence. That works, but real-world tasks are rarely that predictable.

Some agents are better at research. Others are better at analysis or writing. Their costs, latency, reliability, and output quality can differ significantly.

A fixed workflow doesn't necessarily choose the right workers for the job. And without proper controls, an agent can consume more resources than expected or return work that looks convincing but is incorrect.

We wanted to explore a different approach.

Introducing Threadpool

Threadpool is an AI workforce orchestration platform designed to help delegate work to specialized AI agents while keeping cost, quality, and permissions under control.

Instead of treating agents as isolated tools, Threadpool treats them as workers that need to be selected, coordinated, evaluated, and held accountable.

Here's the basic flow:

Understand the task: Interpret the user's goal and break it into smaller tasks.
Find the right workers: Select suitable agents based on their capabilities and relevant performance metrics.
Plan within a budget: Build a workflow that fits the available resources without blindly sacrificing essential steps.
Execute the work: Coordinate agents and manage task dependencies.
Verify the output: Evaluate completed work against quality requirements.
Enforce accountability: Track resource usage, apply execution limits, and record agent performance.

The goal isn't to use as many agents as possible. It's to get the right work done with the right agents, at a reasonable cost, with results that can be evaluated.

What happens when an agent exceeds its authority?

One of the most interesting problems in agentic systems is the gap between what an agent is allowed to do and what it attempts to do.

An agent might receive a budget of 8 tokens but attempt to request 10,000.

A system that relies entirely on the agent to follow instructions has a serious weakness: the agent is effectively policing itself.

Threadpool explores a different model. Resource limits and authorization rules are enforced by the surrounding system, not merely described in a prompt.

Similarly, completing a task doesn't automatically mean an agent deserves full credit. If its output fails the required quality checks, that failure should affect the outcome.

Trust in an autonomous system should come from enforceable rules and verifiable results, not just from good instructions.

Why we're building this

We believe the future of AI won't be limited to individual agents answering questions. More systems will delegate complex tasks across specialized agents.

As that happens, coordination alone won't be enough.

We'll need ways to manage budgets, control permissions, evaluate results, track reliability, and understand which agents consistently perform well.

These aren't glamorous problems, but they're the problems that matter when AI systems move from demos into real workflows.

That's the direction we're exploring with Threadpool.

We're still building, testing, and learning. There are plenty of difficult problems left to solve, especially around evaluation, routing, and making execution reliable under real-world constraints.

If you're working on AI agents, multi-agent systems, orchestration, or AI infrastructure, I'd love to hear what problems you're running into.

Explore Threadpool: https://threadpool.space

The interesting question isn't just how many agents we can build.

It's how reliably we can put them to work.

I Built FormAS — A Form Backend So You Never Have to Build One Again

Ayantik Sarkar — Sun, 21 Jun 2026 03:47:00 +0000

I Got Tired of Building Contact Form Backends, So I Built FormAS

Every time I built a website, portfolio, landing page, or SaaS product, I ended up solving the same problem:

How do I handle form submissions?

The process was always repetitive:

Create an API endpoint
Validate requests
Store submissions
Send email notifications
Add spam protection
Export data when needed

For a simple contact form, it felt like too much work.

So I decided to build FormAS.

What is FormAS?

FormAS is a Form Backend as a Service.

Instead of building and maintaining your own backend, you can create a form endpoint and start receiving submissions instantly.

It works with:

Next.js
React
Static HTML websites
Landing pages
Portfolios
Any frontend application

Features

📧 Email Notifications

Get notified whenever someone submits your form.

🔗 Webhooks

Send submission data to your backend, CRM, Discord bot, automation workflow, or any external service.

🛡️ Spam Protection

Built-in honeypot protection and rate limiting to stop spam and abuse.

📊 Submission Dashboard

View and manage all form submissions from a single dashboard.

📤 Export Data

Export submissions as CSV or JSON anytime.

⚡ Simple API

Just one endpoint. No backend required.

Why I Built It

As a developer, I wanted something simple.

Not a form builder.

Not a website builder.

Just a reliable backend for forms.

Something I could connect to a frontend project in minutes and move on.

Example Integration

<form action="https://api.formas.space/api/submit/YOUR_API_KEY" method="POST">
  <input type="text" name="name" required />
  <input type="email" name="email" required />
  <textarea name="message"></textarea>
  <button type="submit">Send</button>
</form>

That's it. No backend required.

Building Challenges

While building FormAS, I learned a lot about:

API design
Webhooks
Rate limiting with Redis
Spam prevention
Email delivery
Developer experience

One of the biggest lessons was that the "simple" products are often the hardest to build because they need to feel effortless for users.

What's Next?

Planned features include:

File uploads
Team workspaces
Advanced analytics
More integrations
Better webhook tooling

I'd Love Your Feedback

If you've built forms before, I'd love to know:

What's your biggest pain point?
Which feature would make you switch from your current solution?
What should I build next?

Links

🌐 Website: https://formas.space

📚 Documentation: https://formas.space/docs

🚀 Product Hunt: Coming Soon

FormAS is built by me, Ayantik Sarkar, CTO at HoardSpace, and is launching as a HoardSpace Product.

Thanks for reading!

🚀 Built something I personally needed: Elimics

Ayantik Sarkar — Mon, 04 May 2026 06:03:30 +0000

Every time I sent a resume, project, or doc, I had the same question:

“Did they even open it?”

There was no good answer. So I built one.

🧠 What Elimics is

Elimics turns any link into a trackable, controllable asset.

You don’t just share links anymore — you get feedback from them.

⚙️ What it does

Track views, unique visitors & reopens
See last engagement (no more guessing)
Add password protection, expiry & limits
Upload & track documents

Basically: links, but with actual intelligence.

💡 Why I built this

Links today are dumb.

You send them → silence → awkward follow-up.

I wanted something that gives signals, not silence.

🧪 Current Status

Early access is live.

👉 Everything is FREE right now

(Pricing will be introduced later)

🚧 What I’m building next

💰 Paid links (monetization)
⚡ Real-time engagement tracking
🤝 Collaboration features

🙏 Feedback > Praise

If you’re a dev, founder, or someone who shares links often —

I’d genuinely like to know:

What’s missing?
What feels useless?
What would make this a daily tool?

👉 Try it: https://elimics.com

Tear it apart. I’ll fix it.

Pulse UI - I am building My Own UI Component Library (Here’s Why)

Ayantik Sarkar — Tue, 31 Mar 2026 07:04:40 +0000

Try it: https://pulseui-henna.vercel.app/
Github: https://github.com/ayantik2006/pulse-ui

Most developers don’t build UI libraries.

They just install one.

And honestly… that’s the smart move.

So why did I spend time building my own?

The Problem

Every time I started a new project, I ended up doing the same things:

Rewriting buttons
Copy-pasting loaders
Rebuilding toast systems
Tweaking animations again and again

Even with libraries like shadcn/ui, I felt like:

I’m still assembling pieces… not moving fast enough.

The Idea

Instead of depending on multiple tools, I decided to build a single place for reusable, modern UI components.

Something that is:

Fast to copy
Easy to customize
Actually looks good out of the box
Focused on modern UI + animations

So I started building Pulse UI.

What is Pulse UI?

Pulse UI is a growing collection of reusable components like:

Buttons
Loaders
File Upload
Toasts
Accordions
Avatars
Typewriter Effects

But the goal is not just components.

The goal is:

To ship beautiful UIs faster without the headache

What Makes It Different?

I’m not trying to compete with big libraries.

Instead, I’m focusing on:

1. Copy-Paste Simplicity

No heavy setup.

Just take the component and use it.

2. Animation-First Thinking

Most UI libraries treat animation as optional.

Here, it’s part of the design.

3. Built for Real Projects

Not just isolated components.

I’m working on:

Landing page blocks
Reusable sections
Full UI patterns

What I Learned While Building This

1. You Don’t Understand UI Until You Build It

Using components is easy.

Designing them? Different game.

2. Consistency is Hard

Spacing, colors, motion — everything needs to feel connected.

Otherwise it looks like a mess.

3. Developer Experience > Features

Nobody cares how many components you have.

They care how fast they can use them.

What’s Next?

I’m currently working on:

More animated components
Pre-built templates (landing pages, dashboards)
Better documentation
Making everything insanely easy to use

Final Thought

Building your own UI library is not necessary.

But it teaches you things no tutorial will.

And who knows…

Maybe it turns into something people actually use.

If you’re building something similar or have feedback, I’d love to hear it.

Let’s make UI less boring.

🚀