AetherAI — Agentic Task Automation Platform

Inspiration

Most "AI assistants" stop at giving you an answer — you still have to go do the work yourself. We wanted to close that gap: an agent that doesn't just tell you what to do, but understands the request, decides what kind of work it actually is, and carries it through to completion — on a schedule, with a human able to step in when it matters. AetherAI grew out of that goal.

What it does

AetherAI turns a plain-English request into a tracked, executable task.

Understands intent. Every message is routed to a conversation, research, or analysis handler — or parsed directly into a structured task — instead of being force-fit into a single chat response.
Plans and executes. Tasks run as multi-step executions, each step timed and logged, with progress streamed live to the dashboard over Server-Sent Events so you watch the task run instead of waiting on a spinner.
Uses tools. The agent can call a search tool for AI-backed research, a fetch tool (SSRF-guarded) to pull external data, a read-only database tool to query your own tasks/executions/artifacts, and a document tool to look up structured records.
Puts a human in the loop. Any execution can be flagged to require approval before it proceeds — pending, approved, or rejected — so the agent never runs unattended on anything sensitive.
Runs on a schedule. Tasks can fire once or recur daily, weekly, or monthly, handled by a background schedule worker.
Keeps a record. Every AI response, generated document, report, or execution output is saved as a browsable artifact, with image artifacts stored on Cloudinary.
Gives you a full account. Email/password signup with OTP email verification, JWT sessions, and Google Sign-In, backed by a dashboard, analytics view, and per-user activity feed.

How we built it

Backend: Node.js and Express, with MongoDB (via Mongoose) as the data layer. The agent talks to Google Gemini through the OpenAI-compatible SDK, which let us reuse familiar chat-completion patterns while pointing at Gemini's endpoint. Auth is JWT-based with bcrypt password hashing, nodemailer for OTP delivery, and google-auth-library for Google Sign-In. Uploaded/generated images go to Cloudinary.

The core of the system is the agent pipeline: an intent detector routes each message, a planner turns task-shaped requests into ordered steps, and those steps run through an execution engine tracked by an execution manager. Two background workers — a task worker and a schedule worker — poll for due work every 30 seconds so tasks and recurring schedules run without a human triggering them.

Frontend: React 19 on Vite, styled with Tailwind CSS 4, charts via Recharts, icons via lucide-react. A useSSE hook keeps the dashboard subscribed to live execution updates so task progress, approvals, and artifacts show up in real time.

Testing & deployment: Jest and Supertest for integration tests, running against mongodb-memory-server so the suite needs no external database. In production the backend runs as a Docker container on Google Cloud Run (kept at min-instances=1 so the schedule worker stays alive, and max-instances=1 to avoid duplicate scheduled runs), with the frontend on Vercel proxying /api/* to avoid CORS.

Challenges we ran into

Making "agentic" mean something concrete. It was easy to build a chatbot; the hard part was intent detection accurate enough that a research question and an actionable task didn't get treated the same way.
Background work on a request/response backend. Express doesn't give you a worker process for free — we had to build the schedule and task workers as in-process pollers and be deliberate about not letting them double-run across instances, which is why the deployed service is pinned to a single instance.
Keeping tool access safe. The fetch tool can hit arbitrary URLs on the agent's behalf, so it needed SSRF guarding, and the database tool needed to be strictly read-only so the agent could answer questions about your data without ever being able to write to it.
Live updates without over-engineering. We wanted execution progress to feel real-time without standing up a separate pub/sub system, so we built it on Server-Sent Events and an in-process event bus.

Accomplishments that we're proud of

A genuinely end-to-end loop: describe a task in chat, watch it get classified, planned, executed step-by-step with live progress, optionally gated behind human approval, and archived as a reviewable artifact.
A scheduling system that survives restarts and doesn't double-fire, which is a deceptively hard problem on a hackathon timeline.
A tool layer with real guardrails — SSRF protection, read-only DB access — rather than an agent with unrestricted access to everything.

What we learned

How much of "agentic" behavior is really about state management, idempotency, and guardrails rather than the model call itself. The gap between a demo-able agent and a safe one lives almost entirely in the plumbing around it — approvals, scheduling, tool restrictions — not in the prompt.

What's next for AetherAI

Multi-agent collaboration — letting specialized agents hand off sub-tasks to each other instead of one agent doing everything sequentially.
More tool integrations (calendar, email sending, third-party APIs) behind the same approval workflow.
Smarter scheduling — natural-language recurrence ("every weekday morning") instead of fixed daily/weekly/monthly options.
A public API so other apps can trigger AetherAI tasks programmatically.