AutoWork — Autonomous Goal-to-Action Agent

Give AutoWork a goal, approve the plan once, and let an autonomous AI agent research, critique, refine, verify, and deliver actionable results in the background.

Comment

Inspiration

Most AI assistants are excellent at answering questions, but complex work still requires humans to continuously orchestrate the process.

You ask a question, review the answer, identify what is missing, perform additional research, compare information, verify the results, and decide what to do next.

We wanted to change that interaction model.

Instead of asking AI for another answer, we wanted to give it an outcome and let it figure out the work required to achieve it.

That idea led to AutoWork — Autonomous Goal-to-Action Agent.

Our vision is simple:

Give it a goal. Approve once. Let it work.

AutoWork turns a high-level goal into an executable plan, gives the user a single approval checkpoint, and then performs the work autonomously in the background.

What it does

AutoWork transforms a natural-language goal into an autonomous workflow.

The process is:

Goal → Plan → Approval → Execute → Critique → Refine → Verify → Deliver

A user starts by describing what they want to accomplish.

AutoWork analyzes the goal and creates a structured execution plan with tasks, dependencies, and objectives. The user reviews the plan and explicitly approves it.

After approval, the system takes over.

The approved workflow is executed asynchronously using a cloud-based worker. AutoWork can:

  • Break complex goals into actionable tasks
  • Conduct multi-step research
  • Collect and organize evidence
  • Analyze gathered information
  • Critique its own intermediate results
  • Identify missing or weak evidence
  • Automatically perform follow-up research
  • Refine the result
  • Verify conclusions
  • Produce an actionable final outcome
  • Persist execution state and progress

The key difference is that the user doesn't need to repeatedly prompt the system to continue.

For example, instead of asking:

"Research AI coding agents."

the user can provide a much richer goal:

"Research the best AI coding agents for a small software startup and recommend the best option based on price, coding capability, integrations, deployment simplicity, and suitability for a small team."

AutoWork determines the work required to answer that goal, executes the research workflow, evaluates its own findings, and produces a final recommendation.

How we built it

AutoWork is built around Gemini and Google ADK, with Google Cloud providing the asynchronous execution infrastructure.

The architecture separates planning, authorization, execution, and persistent state.

Core architecture

User
  ↓
AutoWork UI
  ↓
Goal Analyzer
  ↓
Planner
  ↓
Structured Action Plan
  ↓
Human Approval
  ↓
Pub/Sub
  ↓
Cloud Run Worker
  ↓
Google ADK + Gemini
  ↓
Research
  ↓
Analysis
  ↓
Critique
  ↓
Refinement
  ↓
Verification
  ↓
Final Result
  ↓
Firestore
  ↓
AutoWork UI

Agent workflow

The autonomous execution loop is designed around:

Research
   ↓
Critique
   ↓
Are the results sufficient?
   ↓
No ──→ Follow-up Research
             ↓
          Re-analysis
             ↓
           Critique
   ↓
Yes
   ↓
Verification
   ↓
Actionable Result

This allows the system to adapt its workflow based on what it discovers rather than following a completely fixed sequence.

Google Cloud

We use:

  • Google ADK for agent orchestration
  • Gemini for reasoning and generation
  • Cloud Run for the API and asynchronous worker
  • Pub/Sub for background job execution
  • Firestore for persistent execution state
  • Cloud Logging for operational visibility

The API does not hold a request open while the agent performs the entire workflow.

After approval, it creates an execution and publishes the execution ID to Pub/Sub. A Cloud Run worker consumes the job and runs the approved workflow independently.

This makes the system genuinely asynchronous.

Human control

Autonomy does not mean removing the human from the loop.

The user remains in control of what the agent is authorized to do.

AutoWork follows:

User defines goal
      ↓
AI creates plan
      ↓
Human reviews
      ↓
Human approves
      ↓
AI executes

The approval boundary is enforced by the application rather than being left to the language model.

Development

Because the hackathon development window was extremely limited, we used Antigravity as a coding and development accelerator to rapidly implement, test, debug, and iterate on the system.

Antigravity is not part of the runtime architecture. The actual application runtime is built using Gemini, Google ADK, Python, and Google Cloud services.

Challenges we ran into

The biggest challenge was moving from a simple agent workflow to a system that could actually operate as an asynchronous autonomous process.

A synchronous prototype is relatively straightforward:

Request → Agent → Result

But a real autonomous workflow requires much more:

Request
  ↓
Authorization
  ↓
Job creation
  ↓
Queue
  ↓
Background execution
  ↓
Persistent state
  ↓
Progress tracking
  ↓
Failure handling
  ↓
Final result

We had to think about what happens if a worker fails, if a message is delivered more than once, or if a user refreshes or leaves the application while the agent is still working.

We addressed these challenges by separating the API from the execution worker, persisting execution state in Firestore, using Pub/Sub for asynchronous delivery, and designing the worker around safe execution and idempotency.

Another challenge was controlling autonomous behavior.

An agent that can endlessly research is not useful or economical. We therefore introduced bounded execution through limits on iterations, searches, retries, and task execution.

Finally, we had to balance autonomy with user control. The system needed to be autonomous after approval without allowing the model itself to decide whether it had permission to execute the workflow.

Accomplishments that we're proud of

We're most proud that AutoWork goes beyond a conversational AI interface and demonstrates a complete goal-to-action execution lifecycle.

The system can move from:

High-level Goal
      ↓
Structured Plan
      ↓
Human Approval
      ↓
Asynchronous Execution
      ↓
Research
      ↓
Self-Critique
      ↓
Autonomous Refinement
      ↓
Verification
      ↓
Actionable Result

We are particularly proud of the critique and refinement loop.

Instead of assuming the first research pass is sufficient, AutoWork evaluates the quality and completeness of its evidence. When gaps are identified, it can initiate additional research before producing the final result.

We're also proud of the cloud architecture.

Separating the user-facing API from the background execution worker allows AutoWork to continue working after the original request has returned. Firestore maintains the execution state, while Pub/Sub provides the asynchronous handoff between the API and worker.

Most importantly, the system demonstrates the interaction model we wanted to build:

The human provides direction. The agent performs the work.

What we learned

We learned that building an agent is much more than connecting an LLM to a set of tools.

The difficult part is designing the system around the model.

We learned the importance of:

  • Explicit planning before execution
  • Human authorization boundaries
  • Persistent state
  • Asynchronous execution
  • Idempotent workers
  • Failure recovery
  • Execution budgets
  • Evidence collection
  • Self-critique
  • Verification
  • Clear separation between AI reasoning and application control

We also learned that autonomy needs boundaries.

A good autonomous agent isn't one that runs forever. It is one that knows what work it has been authorized to perform, has measurable limits, maintains state, recognizes uncertainty, and knows when it has enough evidence to finish.

Most importantly, we learned that the value of agentic AI is not simply better answers.

The larger opportunity is reducing the amount of human orchestration required to get useful work done.

What's next for AutoWork — Autonomous Goal-to-Action Agent

The current version focuses on autonomous research and knowledge-work workflows.

The next step is to make AutoWork capable of completing a wider range of real-world actions.

We envision:

  • More tool integrations for real business workflows
  • Calendar, email, project-management, and communication actions
  • Long-running workflows spanning days or weeks
  • Persistent agent memory
  • More sophisticated task recovery
  • Agent-to-agent collaboration
  • Stronger identity and permission controls
  • Enterprise governance and auditability
  • A registry for reusable specialized agents
  • More advanced observability
  • Human checkpoints for high-impact actions

Ultimately, we want AutoWork to evolve from an autonomous research agent into a general-purpose goal-to-action work platform.

The long-term vision is simple:

Today, we interact with AI by giving it prompts.

Tomorrow, we should be able to give it outcomes.

Give it a goal. Approve once. Let it work.

Built With

  • agentic-ai
  • ai
  • ai-agents
  • autonomous-agents
  • cloud-run
  • fastapi
  • firestore
  • gemini
  • generative-ai
  • google-adk
  • google-cloud
  • llm
  • multi-agent-systems
  • pub/sub
  • python
Share this project:

Updates