ARIOS — Autonomous AI Taskmaster

An autonomous AI taskmaster that turns natural-language goals into trackable, intelligently executed tasks.

Comment

Inspiration

Most AI assistants are great at answering questions, but they often stop at generating a response. I wanted to explore a different idea: what if AI could treat a user's request as a task rather than just a conversation?

That idea led us to build ARIOS — Autonomous AI Taskmaster, an AI agent designed to turn natural-language requests into trackable tasks and provide a result after processing them.

What it does

ARIOS provides a simple interface where users can give the agent a task in natural language. Behind the interface, the request is sent to a FastAPI backend, where our agent is powered by Google ADK and Gemini.

The system maintains a task lifecycle with states such as:

  • queued
  • planning
  • working
  • completed
  • failed

Each task receives a unique ID and can be queried for its current status and result.

I also integrated Google Cloud Firestore for task persistence. Because our deployment environment does not always have direct Google Cloud credentials available, I designed the backend with an in-memory fallback so the application can remain operational without Firestore authentication.

The frontend is deployed on Vercel, while the backend runs on Google Cloud Firestore, giving ARIOS a fully deployed cloud architecture.

How I built it

The main technologies used were:

  • React + Vite — frontend
  • FastAPI — backend API
  • Google ADK — agent orchestration
  • Gemini — AI reasoning and generation
  • Google Cloud Firestore — backend deployment
  • Vercel — frontend deployment
  • GitHub — version control

The main flow is:

User
  ↓
React Frontend
  ↓
FastAPI Backend
  ↓
Google ADK
  ↓
Gemini
  ↓
Task Result
  ↓
Frontend

For autonomous tasks, the backend creates a task, assigns it an ID, updates its progress state, runs the ARIOS agent, and stores the final result.

Challenges I ran into

One of our biggest challenges was deploying the backend.

Our local Google Cloud environment could authenticate with Firestore through Application Default Credentials, but our Render deployment did not have those credentials. This initially caused the backend to crash during startup.

Instead of making the entire application dependent on Firestore authentication, I changed the architecture so that Firestore is used when available while the backend can safely fall back to in-memory task storage.

I also encountered API rate limits while testing Gemini. This highlighted another important aspect of building AI applications: model availability, quotas, authentication, and deployment infrastructure all need to be considered alongside the application code itself.

Accomplishments that I am proud of

Building ARIOS from an idea into a fully deployed AI application was our biggest accomplishment.

I am especially proud of:

  • 🤖 Building an AI agent with Google ADK that can receive natural-language tasks and process them asynchronously.
  • ⚡ Creating an asynchronous task system with unique task IDs and lifecycle states such as queued, working, completed, and failed.
  • 🌐 Deploying a full-stack application with the React frontend on Vercel and the FastAPI backend on Firestore.
  • ☁️ Integrating Google Cloud Firestore for persistent task storage while designing a fallback mechanism for environments without cloud credentials.
  • 🧩 Connecting multiple cloud services into one working architecture instead of keeping the project as a local prototype.
  • 🎨 Building a dedicated AI-task interface rather than simply wrapping a chatbot API in a basic UI.
  • 🔧 Handling real deployment challenges, including cloud authentication, API limits, dependency issues, and production configuration.
  • 🚀 Taking ARIOS from concept to a publicly accessible MVP that can be demonstrated and tested through the web.

The accomplishment I am most proud of is that ARIOS isn't just an idea or a local demo — it's a working cloud-deployed AI application with a foundation that can be expanded into a much more capable autonomous task system.

What I learned

Building ARIOS taught me that creating an AI application is about much more than connecting a language model to a chat interface.

I learned how to:

  • Build and structure an agent using Google ADK
  • Design APIs for asynchronous task execution
  • Track long-running task states
  • Integrate Firestore with a Python backend
  • Deploy a full-stack AI application
  • Handle cloud authentication and deployment constraints
  • Design a frontend around an AI-agent workflow rather than a traditional chatbot

One of the biggest lessons was learning how different parts of a cloud application depend on each other. A feature that works locally may require completely different authentication or configuration when deployed.

What's next for ARIOS — Autonomous AI Taskmaster

ARIOS is designed to be extensible. Future versions could allow ARIOS to:

  • Break complex goals into multiple subtasks
  • Use external tools and APIs
  • Execute multi-step workflows
  • Maintain longer-term task history
  • Recover from failed steps
  • Provide richer real-time progress updates

Our goal is to evolve ARIOS from an AI that answers requests into an AI that can understand a goal, plan the work, execute it, and report back on the outcome.

Final Thought

The core idea behind ARIOS is simple: _ Don't just ask AI what to do. Give it something to do. _

Built With

Share this project:

Updates