Async-native task queue for I/O-heavy workloads

Problem Context

Developers running async I/O workloads (e.g., LLM API calls, external API orchestration) need to parallelize tasks efficiently. Current tools like Celery or Dramatiq force sequential task execution at the worker level, even if the task code is async. This limits concurrency to the number of prefork workers, wasting RAM and slowing down throughput.

Pain Points

Users try increasing worker processes to scale, but this spikes RAM usage. Async code inside tasks runs sequentially at the worker level, defeating the purpose of async. Alternatives like Celery or Dramatiq don’t support true async task scheduling, leaving users stuck with manual workarounds or inefficient scaling.

Impact

The bottleneck costs time (longer test cycles, delayed releases) and money (wasted cloud compute, manual scaling). Teams miss opportunities to scale workloads or reduce infrastructure costs. Frustration grows as they patch around limitations in tools designed for sync workloads.

Urgency

This is a blocker for teams running revenue-generating async workloads (e.g., LLM testing, API pipelines). Ignoring it means slower iterations, higher costs, and lost productivity. The problem worsens as workloads grow, making it a critical fix for scaling teams.

Target Audience

Backend engineers at SaaS startups, data teams running async pipelines, and LLM developers. Any team using async I/O (e.g., FastAPI, asyncio) with Celery/Dramatiq but hitting concurrency limits. Common in industries like AI, fintech, and real-time APIs.

Solution Approach

A lightweight task queue that schedules async tasks directly onto event loops, bypassing prefork workers. Uses Redis for persistence and a simple API for task submission. Workers run as async processes, executing tasks concurrently without artificial limits. Designed for I/O-heavy workloads where async is critical.

Key Features

1. Redis-backed persistence: Reliable task storage with minimal overhead.
2. Async-native API: Submit tasks via async HTTP or Python client.
3. Auto-scaling: Workers dynamically adjust to load without manual tuning.

User Experience

Users replace Celery with this queue in minutes. They submit tasks via API or Python client, and the system handles concurrency automatically. No need to manage worker processes—just run workers as async services. Monitoring shows real-time task throughput and resource usage.

Differentiation

Unlike Celery/Dramatiq, this is built for async-first workloads. No prefork workers, no RAM bloat. Works seamlessly with FastAPI, asyncio, and other async frameworks. Simpler to scale than Celery (no worker process management) and more performant for I/O-bound tasks.

Scalability

Start with 1–2 workers; add more as needed. Redis handles persistence, and workers auto-scale based on queue depth. Supports horizontal scaling for high-throughput workloads. No manual tuning required—just deploy workers and let the system balance load.

Expected Impact

Users reduce task completion time by 50%+ and cut cloud costs by eliminating over-provisioned workers. Faster iterations for LLM testing, API pipelines, and data processing. Teams scale workloads without hitting concurrency limits, improving productivity and revenue.