AgentOS

AgentOS is an autonomous workspace: give it a goal, and it plans the work, builds any missing tool integrations on the fly via auto-generated MCP connectors, then executes and delivers.

Comment

AgentOS — The Autonomous Workspace That Builds Its Own Tools

Inspiration

Modern AI assistants are becoming very good at answering questions, but getting real work done still requires people to constantly supervise them.

We saw a gap between chatting with AI and actually delegating a job to AI.

Automation platforms such as workflow builders are powerful, but users still have to define workflows, connect services, select tools, handle failures, and maintain integrations themselves.

We wanted to explore a different approach:

What if a user could simply describe the outcome they want, and an AI system could figure out how to accomplish it?

That question led us to build AgentOS.

AgentOS is designed as an autonomous AI workspace where the user gives a goal instead of manually constructing every workflow step. The system can understand the goal, create a plan, select tools, execute the work, persist its state, and eventually extend its own capabilities by creating missing MCP-based integrations.

A second problem inspired the project: professional documents such as resumes are still surprisingly manual. Users may know what they want their resume to communicate, but not how to write optimized LaTeX, structure content for ATS systems, or maintain different versions for different jobs.

That led us to make intelligent document generation, especially resume generation and optimization, part of the AgentOS vision.

What We Built

AgentOS is being designed around several core capabilities:

Autonomous Agent Execution

A user can provide a high-level instruction such as:

"Find relevant software engineering internships,
analyze them against my profile,
and prepare the best opportunities for me."

Instead of requiring the user to manually build a workflow, AgentOS is designed to transform the request into:

User Goal
   ↓
Intent
   ↓
Plan
   ↓
Agent Execution
   ↓
Tool Calls
   ↓
Verification
   ↓
Result

The current foundation uses a Next.js frontend, a Python/FastAPI backend, Google ADK, Gemini, and Firestore-backed execution state.

The first working vertical slice already demonstrates the core pattern:

Next.js
   ↓
FastAPI
   ↓
Intent Agent
   ↓
Planner Agent
   ↓
Orchestrator Agent
   ↓
Real Tool
   ↓
Firestore
   ↓
Execution Timeline

This foundation is important because the system is being built around real execution state rather than simulated AI responses.

The Bigger Idea: Agents That Can Build Their Own Tools

One of the main ideas behind AgentOS is that an agent should not be permanently limited to the integrations developers happened to build beforehand.

When an agent needs a capability, the system can first check its tool and MCP registry.

If the capability already exists:

Agent → Existing MCP → Tool → Result

If it does not exist, the planned architecture allows:

Agent
  ↓
Missing Capability
  ↓
API / OpenAPI Discovery
  ↓
MCP Generation
  ↓
Validation
  ↓
Sandbox Testing
  ↓
Registration
  ↓
Tool Available to Agent

The goal is to make AgentOS self-extending rather than just another collection of pre-built integrations.

We deliberately avoid claiming that an MCP can be generated for literally every application. The intended approach is to support applications with documented APIs or OpenAPI specifications and validate generated connectors before they can be used.

Autonomous Scheduling

Another important part of AgentOS is the ability to delegate work for later.

Instead of:

"Run this workflow now."

a user can eventually say:

"Every Monday at 9 AM, perform this task automatically."

The planned execution model is:

Cloud Scheduler
      ↓
Pub/Sub
      ↓
AgentOS Worker
      ↓
Workflow
      ↓
Agents
      ↓
Tools
      ↓
Verified Result

The purpose is to allow workflows to continue operating even when the user's browser is closed.

This changes the experience from an assistant that waits for prompts into a system that can continue working on the user's behalf.

Intelligent Resume Creation

AgentOS also contains a dedicated vision for resume intelligence.

Instead of asking users to learn LaTeX or manually rewrite their resume for every job, the system can work from structured profile information and a job description.

The intended workflow is:

Job Description
      +
User Profile
      ↓
Requirement Extraction
      ↓
Semantic Matching
      ↓
Resume Generation
      ↓
ATS Analysis
      ↓
Optimization
      ↓
Final Resume

The generated resume can be represented in multiple formats, including:

  • LaTeX
  • Markdown
  • HTML/CSS
  • JSON
  • PDF

This makes the resume more than a static document. It becomes an artifact that can be analyzed, optimized, versioned, and regenerated for different opportunities.

What We Learned

One of the biggest lessons from building AgentOS was that agentic systems are much more than prompts.

A single LLM call can produce an impressive demo, but a reliable autonomous system requires much more:

  • structured state
  • deterministic workflow transitions
  • validated schemas
  • tool contracts
  • persistence
  • asynchronous execution
  • retries
  • security boundaries
  • observability
  • verification
  • controlled permissions

We learned to separate responsibilities carefully.

The AI should handle reasoning and decisions such as:

"What should I do next?"

while deterministic software should handle things such as:

"Is this action allowed?"

"Is this schema valid?"

"Should this task be retried?"

"Did the tool actually succeed?"

This separation makes the system more predictable and much easier to reason about.

Challenges

Building an Actual Agent Runtime

Our first challenge was avoiding the temptation to build a chatbot disguised as an autonomous system.

We needed a real execution flow in which the agents could create structured intent, generate a plan, execute tools, and persist the resulting state.

This required introducing clear boundaries between the Intent Agent, Planner Agent, and Orchestrator.

Keeping AI and Deterministic Logic Separate

LLMs are excellent at reasoning, but they should not be trusted with critical state transitions or permission enforcement.

We therefore designed the architecture so that deterministic code controls state, persistence, permissions, retries, and validation, while Gemini and ADK are used where reasoning is actually required.

Dynamic Tool Generation

Allowing an AI system to generate executable integrations introduces serious security risks.

Generated code cannot simply be executed inside the main application.

The planned MCP architecture therefore introduces validation and sandboxing before generated connectors are registered.

Persistent Execution

A real autonomous system cannot depend on a browser tab remaining open.

This pushed the architecture toward persistent workflow state and asynchronous execution using Google Cloud services.

Building for Production Instead of a Demo

Another challenge was resisting shortcuts.

A static success message can make a prototype appear autonomous, but it does not create a reliable system.

We therefore focused on real APIs, real persistence, structured schemas, testing, and cloud-native architecture from the beginning.

Technology

AgentOS is built around Google's AI and cloud ecosystem.

Core technologies include:

Google Gemini
Google ADK
Python
FastAPI
Next.js
TypeScript
Firestore
Cloud Run
Pub/Sub
Cloud Scheduler
Cloud Storage
Secret Manager
Terraform

The architecture is intentionally modular so new agents, tools, MCP connectors, plugins, and workflows can be added without rebuilding the core platform.

Why AgentOS?

We do not want AgentOS to be another chatbot.

We also do not want it to simply be another workflow editor where humans manually connect every step.

The long-term vision is:

Traditional Automation

User
 ↓
Design Workflow
 ↓
Choose Every Tool
 ↓
Configure Every Step
 ↓
Monitor Failures
 ↓
Maintain Integration


AgentOS

User
 ↓
Describe Goal
 ↓
AgentOS Plans
 ↓
Agents Execute
 ↓
Missing Tools Can Be Built
 ↓
Failures Can Be Recovered
 ↓
Workflow Can Run Automatically
 ↓
User Receives Result

That is the shift we are exploring:

From AI that answers to AI that operates.

The Vision

Our long-term goal is for AgentOS to become an operating system for autonomous work.

A user should eventually be able to say:

"Handle this."

and AgentOS should be able to determine:

  • which agents are required
  • which tools are required
  • which integrations are available
  • which integrations must be created
  • what information it needs
  • what actions it is allowed to perform
  • how the workflow should execute
  • how to recover when something fails
  • when the task should run again
  • and how to verify that the result is actually correct

The result is not just another AI assistant.

It is an attempt to build a system where AI can plan, act, learn from execution, create capabilities, and continue working autonomously within clearly defined boundaries.

Built for the Google Agentic AI Hackathon

AgentOS was built around the core idea of moving beyond conversational AI toward autonomous, tool-using agents that can execute meaningful multi-step work.

Our goal was not to demonstrate that an LLM can generate text.

Our goal was to demonstrate that an AI system can become an operator.

Share this project:

Updates

Submission history