Vazir-The Task Master

From opportunity to application—an autonomous AI agent that gets the work done

Comment

# CareerPilot — Autonomous AI Agent for Career Workflows

Inspiration

We noticed that applying for internships and jobs is rarely a single task. A student may discover an opportunity, read a long job description, compare requirements with their skills, tailor their resume, prepare for the role, track the deadline, and remember to follow up.

The problem is not that students lack access to AI tools. The problem is that most AI tools still wait for the user to tell them what to do next.

That inspired us to build CareerPilot, an autonomous AI agent that works more like a smart coordinator than a chatbot.

Our goal was simple:

Give the agent an opportunity, and let it figure out what needs to happen next.

Instead of requiring a user to manually trigger every step, CareerPilot turns an incoming opportunity into an event-driven workflow and autonomously routes the work to the right agents and services.

What CareerPilot Does

CareerPilot starts when a new internship or job opportunity is detected.

The workflow looks like:

Opportunity Detected → Analyze → Match → Decide → Route → Execute → Track

For example, when a Software Developer internship is detected, CareerPilot can:

  • Extract the role, requirements, skills, and deadline.
  • Retrieve the user's profile and existing skills.
  • Compare the opportunity against the user's profile.
  • Identify strengths and skill gaps.
  • Calculate a suitability score.
  • Decide what actions are required next.
  • Create an application workflow.
  • Generate personalized preparation tasks.
  • Prepare application materials.
  • Update the application tracker.
  • Monitor deadlines and trigger follow-up workflows.
  • Pause and request human approval before consequential actions.

The user does not have to repeatedly prompt the system between these steps.

Why It Fits the Taskmaster Track

CareerPilot is designed around the core Taskmaster concept:

An event triggers the agent, the agent decides what needs to happen, and the workflow continues through autonomous routing and actions.

A traditional chatbot works like:

User → Prompt → AI → Response
       ↓
User → Next Prompt → AI → Response

CareerPilot works differently:

Event
  ↓
Gemini Agent
  ↓
Understand the event
  ↓
Decide what needs to happen
  ↓
Autonomous routing
  ↓
Specialized agents
  ↓
Actions
  ↓
New events
  ↓
More actions
  ↓
Workflow completed

This allows CareerPilot to operate beyond a standard chat loop.

How We Built It

We built CareerPilot as a multi-agent, event-driven system using Google's AI and cloud technologies.

Core Technologies

  • Gemini 3.5+ — used for reasoning, information extraction, planning, personalization, and routing decisions.
  • Google ADK — used to build and coordinate the AI agents.
  • Google Cloud Run — used to run the backend and agent services.
  • Google Cloud Pub/Sub — used for asynchronous, event-driven communication between workflow stages.
  • Firestore — used for persistent storage of user profiles, opportunities, tasks, workflow states, deadlines, and application history.

Agent Architecture

The system has a central Orchestrator Agent that determines what should happen next.

It can delegate work to specialized agents such as:

                    CareerPilot
                  Orchestrator
                       │
       ┌───────────────┼────────────────┐
       │               │                │
       ▼               ▼                ▼
 Opportunity       Profile/Match    Application
    Agent              Agent           Agent
       │               │                │
       └───────────────┼────────────────┘
                       ▼
                 Task / Follow-up
                      Agent

Each agent has a specific responsibility rather than asking one model to perform the entire workflow.

Event-Driven Workflow

One of the most important parts of CareerPilot is the event system.

For example:

NEW_OPPORTUNITY
       ↓
Pub/Sub
       ↓
Opportunity Agent
       ↓
OPPORTUNITY_ANALYZED
       ↓
Profile/Match Agent
       ↓
MATCH_COMPLETED
       ↓
Orchestrator
       ↓
APPLICATION_WORKFLOW_CREATED
       ↓
Application Agent
       ↓
RESUME_READY
       ↓
Human Approval
       ↓
APPLICATION_READY

This structure allows different parts of the system to work independently and makes it possible to continue workflows asynchronously.

Autonomous Routing

The most important capability we wanted to demonstrate was autonomous decision-making about the next step.

For example:

IF opportunity detected
        ↓
Analyze requirements

IF match score > threshold
        ↓
Create application workflow

IF important skills are missing
        ↓
Create preparation tasks

IF deadline is approaching
        ↓
Increase priority

IF action requires user authorization
        ↓
Pause workflow and request approval

Gemini provides the intelligence required to understand the situation and determine the appropriate route, while the application logic and cloud infrastructure provide controlled execution.

This separation makes the system more reliable than simply allowing an LLM to perform unrestricted actions.

What We Learned

Building CareerPilot taught us that building an autonomous agent is very different from building a chatbot.

We learned how to:

  • Design event-driven workflows.
  • Build multi-agent systems with Google ADK.
  • Use Gemini for reasoning and routing.
  • Maintain persistent state using Firestore.
  • Use Pub/Sub for asynchronous processing.
  • Deploy agent services using Cloud Run.
  • Design workflows that can continue without constant user interaction.
  • Introduce human approval at important decision points.
  • Think about failures, retries, validation, and workflow state.

Most importantly, we learned that autonomy is not simply giving an AI more permissions.

A useful autonomous agent needs clear responsibilities, controlled tools, reliable state management, and well-defined boundaries.

Challenges We Faced

1. Designing reliable autonomous routing

The biggest challenge was deciding how the agent should determine the next action.

We solved this by combining Gemini's reasoning capabilities with structured workflow states and explicit routing rules.

2. Managing asynchronous execution

A real workflow cannot assume that every action happens instantly.

Pub/Sub allowed us to separate workflow stages and design the system around events rather than a single synchronous conversation.

3. Maintaining state

The agent needs to remember where a workflow currently stands.

Firestore provides persistent state for opportunities, tasks, deadlines, and application progress.

4. Balancing autonomy with human control

We did not want the agent to blindly perform consequential actions.

CareerPilot can autonomously analyze, prepare, organize, and track work, while actions such as final submission require human approval.

5. Building something beyond a chatbot

Our biggest design challenge was resisting the temptation to make a sophisticated chat interface.

Instead, we focused on making the workflow itself the product.

The dashboard is primarily there to show what the agent is doing, what it has completed, what is currently running, and where human input is required.

What Makes CareerPilot Different

CareerPilot is not designed to be another AI assistant that waits for questions.

Its core principle is:

Don't ask the user what to do next. Understand the event and determine what should happen next.

The agent can:

Observe → Reason → Route → Act → Store State → Trigger the Next Event

This creates a continuous workflow rather than a sequence of isolated AI responses.

Expected Impact

CareerPilot can reduce the repetitive coordination work involved in internship and job applications.

Instead of spending time manually moving information between different steps, users can let the agent coordinate the workflow while retaining control over important decisions.

The same architecture can eventually be adapted beyond career applications to workflows such as:

  • Student project management
  • Academic assignment workflows
  • Freelance lead management
  • Recruitment pipelines
  • Small-business operations
  • Personal productivity workflows

The career application scenario is our starting point, but the underlying system is designed as a general autonomous workflow engine.

Our Vision

We believe the next generation of AI applications will not be defined by how well they answer a prompt.

They will be defined by how well they complete a goal.

CareerPilot is our attempt to move from:

"Ask AI what to do."

to:

"Give AI a goal. Let it coordinate the work."

CareerPilot doesn't just respond to the user—it responds to events, takes action, maintains state, and keeps the workflow moving.

Built With

  • adk
  • agent
  • agents
  • ai
  • architecture
  • automation
  • autonomous
  • cloud
  • computing
  • event-driven
  • firestore
  • gemini
  • generative
  • google
  • language
  • learning
  • machine
  • multi-agent
  • orchestration
  • processing
  • pub/sub
  • systems
  • technology
  • workflow
Share this project:

Updates

Submission history