June 23, 2025

My Week Long Journey with Google Agent Development Kit (ADK) for a Hackathon Entry

This post was created specifically for the purpose of entering the Google ADK hackathon which concluded on June 23, 2025.

The DevPost project page has more details on the entry itself.

This post details the development of a prototype solution leveraging the Google Agent Development Kit (ADK) to streamline the recruitment process and enhance the candidate experience. Developed during this hackathon, the solution aims to address the inefficiencies and frustrations inherent in traditional recruiting and hiring practices.

Challenge

The current recruitment landscape is plagued by inefficiencies.  Traditional methods are costly (averaging $4,700 per hire, escalating to over $28,000 for executive roles) and often leave both recruiters and candidates feeling frustrated.  The reliance on static resumes and keyword-driven searches often misses qualified candidates, while the lack of transparency and feedback creates a negative experience for job seekers. 

The solution aims to address these challenges by introducing an agent-based workflow that automates repetitive tasks and provides a more engaging and informative experience for all stakeholders while always keeping humans-in-the-loop.

Solution: Multi-agent Recruiting Process

The hackathon entry reimagines the recruitment process by leveraging a multi-agent workflow. The system focuses on two key areas: streamlining internal processes and empowering candidates.  The core concept is to offload repetitive tasks from recruiters, allowing them to focus on building relationships and assessing candidate fit. For candidates, the system provides a dynamic assessment, real-time feedback, and targeted engagement questions to uncover deeper insights.  This isn’s about replacing human interaction; it’s about augmenting the process with AI to improve efficiency and transparency.

Technical Implementation

Developed in under a week during this hackathon entry is built on the following technology stack:

• Python: The primary programming language for agent logic and API development.
• FastAPI: Used to create a robust and performant web UI for end users.
• Google Agent Development Kit (ADK): The core framework for defining and orchestrating agents. The ADK’s intuitive interface and sample code significantly accelerated development.
• SQLite: Currently used for maintaining both application data and session state
• Google Cloud Build, Cloud Run, and Logging: Used for build, deployment and monitoring.

ADK, FastAPI and custom HTML/CSS

One of the first things I did when I decided to spend a week on this was to learn how to get my own HTML pages displayed instead of relying solely on the default ADK tools. This was a pivotal moment. I realized that the ADK itself doesn't dictate a specific front-end technology. It's designed to be flexible, allowing you to build your own user interfaces using your preferred web framework. This meant I could leverage my existing knowledge of web development principles. The ability to bypass the default tools and directly interact with the agent's logic through custom routes opened up a world of possibilities.

#app = FastAPI()
app: FastAPI = get_fast_api_app(
    agents_dir=AGENT_DIR,
    allow_origins=["*"],
    web=False
)
app.include_router(landing_router)
app.include_router(jobreq_router)
app.include_router(candidate_router)

Once I understood that the ADK was flexible in its front-end requirements, it was a fairly quick move to building my own routes and templates. This involved defining custom endpoints (routes) that would handle specific requests and render HTML templates to display the data or control the agent's actions. You essentially create a web application (using a framework like Flask, Django, or Node.js) that interacts with the agent's logic exposed by the ADK. This allows you to define your own data visualizations, user interfaces, and workflows.

Here's a simplified overview of the steps involved:

1. Choose a Web Framework: Select a framework like Flask, Django, or Node.js.
2. Set up your Project: Create a new project using your chosen framework.
3. Integrate with the ADK: Write code to interact with the agent's logic exposed by the ADK.
4. Define Routes: Create endpoints (routes) that handle specific requests.
5. Render HTML Templates: Use a templating engine (like Jinja2 in my case) to create dynamic HTML pages that display data or provide controls for the agent.

ADK Agent Architecture

Callbacks are useful (especially for logging and debugging)

ADK provides a robust set of callbacks OOTB that can support in active development and as part of the overall flow of logic. Majority of below code is from Google's sample code but notice lines 26-29, that's an opportunity to trap the agent's output in a session state or perform whatever other actions necessary.

Most importantly, it's a great way to trace and add debug prints throughout agent, model and tooling execution. The official docs provide more info if needed.

def after_agent_callback(callback_context: CallbackContext) -> Optional[types.Content]:
    """
    Simple callback that logs when the agent finishes processing a request.

    Args:
        callback_context: Contains state and context information

    Returns:
        None to continue with normal agent processing
    """

    # Sleep for 2 seconds to ensure agent output in state
    # time.sleep(2)

    # Get the session state
    state = callback_context.state

    # Access the agent's output (JSON string)
    output_json = state.get("job_req_title_check_response", "")
    print(f"Output JSON: {output_json}")

    # Remove Markdown code block markers from the string
    clean_json = re.sub(r"^```json\s*|\s*```$", "", output_json.strip())
    output_data = json.loads(clean_json)

    print(f"Output Data: {output_data.get('revised_job_title', 'No revised job title found')}")
    revised_job_title = output_data.get("revised_job_title")
    state["revised_job_title"] = revised_job_title

    # Calculate request duration if start time is available
    timestamp = datetime.now()
    duration = None
    if "request_start_time" in state:
        duration = (timestamp - datetime.fromisoformat(state["request_start_time"])).total_seconds()

    # Log the completion
    print("=== AGENT EXECUTION COMPLETED ===")
    print(f"Request #: {state.get('request_counter', 'Unknown')}")
    if duration is not None:
        print(f"Duration: {duration:.2f} seconds")

    # Print to console
    print(
        f"[AFTER CALLBACK] Agent completed request #{state.get('request_counter', 'Unknown')}"
    )
    if duration is not None:
        print(f"[AFTER CALLBACK] Processing took {duration:.2f} seconds")

    return None

Challenges & Solutions

A key challenge was implementing long-running functions, a critical component for complex workflows. The ADK’s current limitations in this area necessitated the use of a SQLite database for maintaining state. This experience highlighted the importance of ADK’s session state and callbacks for debugging and workflow management.

I'm actively exploring solutions to integrate full long-running functionality in future iterations. Learning FastAPI, SQLAlchemy and Pydantic in short order was also a significant learning curve, but well worth the effort.

Accomplishments & Lessons Learned

Pulling this together in under a week was a significant accomplishment. The ability to rapidly prototype and iterate using the ADK’s framework and it's rich set of docs and examples was invaluable. We gained a deeper understanding of: (1) The power of agent-based development for solving complex problems and (2) the importance of session state management and callbacks in ADK workflows.

This hackathon entry demonstrates the potential of the Google Agent Development Kit to revolutionize agentic AI development, especially where multiple agents and different types of workflows are required.

Source code for hackathon entry is on GitHub.