This is a submission for the Google AI Agents Writing Challenge: Learning Reflections
This AI Agents Intensive course fundamentally shifted my perspective from “LLMs that answer questions” to agents that perceive, decide, and act in the real world using tools, memory, and orchestration. Through the capstone, you took these abstract ideas and implemented Mukti Scholar, a production-ready multi-agent system that can turn any research topic into a high‑quality, literature review pipeline end‑to‑end.
Learning Journey:
Day 1 (agent foundations) I internalized that agents are not just chatbots but autonomous components with roles, goals, and tool access, and that real systems come from composing many small, single‑responsibility agents instead of one giant prompt.
Day 2 deepened this with tooling and MCP, showing how agents “take action” via OpenAPI tools, PDF parsers, custom functions, and even agents-as-tools, which you later mirrored through search, clustering, citation formatting, and PDF generation in my Capstone project
Day 3’s focus on sessions, memory, and vector stores changed how I think about state: instead of stateless prompts, I now design systems with per-run session state, long‑term Memory Banks, and semantic retrieval over embeddings so an agent can remember topics, preferences, and prior runs.
Day 4 highlighted agent quality—logging, tracing, metrics, and evaluation—which I translated into an Observability System and evaluator that measure coverage, coherence, writing quality, and gap detection, not just whether the code ran.
Day 5 closed the loop with prototype‑to‑production thinking, A2A protocol, and deployment to Vertex AI Agent Engine, pushing me to design Mukti Scholar as a service that can be called by other agents and scaled in the cloud rather than as a one-off notebook.
Concepts that resonated most:
Two ideas especially stood out. First, the orchestrator pattern: using a single high-level agent to coordinate specialized sub‑agents with clear contracts, which gave me a mental model for designing complex systems while keeping each component simple and testable. Second, multi-agent patterns—sequential, parallel, and loop—clicked as practical levers for latency, robustness, and correctness, and I saw how swapping patterns (e.g., parallelizing search and summarization) can turn a slow prototype into a responsive system.
I also connected deeply with context engineering and RAG as system design, not just prompt tricks: using summaries instead of full PDFs, thematic clustering to shape context, and retrieval per section of the review gave me a concrete blueprint for scaling agents to longer workflows.
Finally, the emphasis on observability and evaluation resonated because it mirrors production data systems: I now think of agents as services(AaaS) that must expose metrics, traces, and quality scores so they can be debugged, tuned, and trusted.
How my mental model of agents evolved:
At the start, I likely saw agents as “smart LLM wrappers” that execute tools when asked; by the end, my view evolved to agents as distributed, stateful microservices with explicit responsibilities and contracts. I can now design around artifacts and state transitions—papers, embeddings, themes, gaps, drafts—flowing through the system, with each agent transforming the state and updating workflow status in a session record.
My understanding also expanded from single-agent loops to ecosystems of agents that talk to each other, including remote A2A agents that expose capabilities over HTTP and can themselves call Mukti Scholar as a service. Perhaps most importantly, I now treat memory and evaluation as first-class citizens: agents are not just about producing an answer but about remembering what matters across runs and proving that their behavior meets defined quality thresholds over time.
Showcasing my capstone: Mukti Scholar Agent
My capstone, Mukti Scholar Agent, is a multi-agent autonomous system that converts a research topic into a publication-ready literature review in under two minutes, targeting the “Agents for Good” theme by democratizing access to high-quality research workflows. Architecturally, it uses 10 specialist agents plus an orchestrator, organized into three stages—Topic Understanding & Discovery, Analysis & Synthesis, and Gaps, Writing & Output—each aligned directly with the course’s patterns, tools, memory, observability, and deployment pillars.
Key technical achievements include:
Parallel search and summarization across Google Scholar, arXiv, and Semantic Scholar, plus loop-based PDF retrieval with retries, which compresses what used to be tens of hours of work into minutes while remaining fault tolerant.
Embedding-based thematic clustering and comparative analysis, where you generate vectors, run k‑means, label clusters via an LLM, and then compare methods, datasets, and findings across themes to surface patterns and contradictions.
A RAG-powered literature review writer that pulls from the vector store to assemble a structured review (intro, thematic analysis, gaps, conclusion) and a deterministic citation agent that formats references in APA/Harvard/IEEE, culminating in a PDF and supplementary artifacts like cluster diagrams and gap summaries.
What building the capstone taught me:
Building Mukti Scholar turned the course concepts into muscle memory in several ways. I learned how to translate requirements (“cover all ADK concepts”) into a concrete agent graph, mapping Day 1–5 topics directly to agents, tools, memory services, observability modules, and deployment steps. I experienced first-hand why separation of concerns and single-responsibility agents matter: debugging, testing, and iterating on one agent (e.g., gap detection or clustering) became manageable because the rest of the system was insulated behind clear interfaces.
I also gained a strong sense of engineering trade‑offs in agentic systems: balancing realism vs. simulation for tools, deciding where to use deterministic logic vs. LLM reasoning (especially for citations and evaluation), and designing evaluation metrics that reflect real researcher needs like coverage and gap quality. Finally, working through exposure via the A2A protocol and preparing deployment configs for Vertex AI Agent Engine gave me confidence that you can move from a notebook experiment to a scalable, callable service—fulfilling the course’s promise that by the end you can build everything from simple agents to sophisticated multi-agent systems.
Here is the detailed Git Repo link. https://github.com/ajoys24/Google_Agents_Intensive_Capstone_Project
Top comments (0)