Pyahu Scrum Orchestration

WorkFlow
Dashboard
C4 Models

Inspiration

A persistent challenge stands out in software development: the growing chasm between a raw business idea and the rigorous technical documentation required to execute it. While standard AI chatbots excel at drafting emails, they fall short at executing complex, multi-step engineering workflows—especially when those workflows require human judgment at critical decision points. Pyahu Scrum was inspired by the need to democratize that complexity. Designed specifically for the Taskmaster track, it acts as an autonomous multi-agent framework that translates a messy, high-level business vision into Architecture Decision Records (ADRs), Product Requirements Documents (PRD), technical specifications, and actionable development tickets—dispatching specialized ADK agents to do the heavy lifting asynchronously in the background.

What it does

Pyahu Scrum is an autonomous workflow manager that moves far beyond the standard chatbot. Once a user inputs a raw business idea, three specialized agents take over:

Interactive Elicitation (OrchestratorAgent): Instead of generating specs blindly, the system conducts a structured interview—up to 4 rounds of targeted questions with recommendations—so it truly understands the project's scope, stack, constraints, and audience before generating documentation.
Human-in-the-Loop Approval: After the interview, the Gemini model generates a structured scope summary. The user reviews and either approves or sends feedback. The system refines and re-presents until the user is satisfied.
Chained Artifact Generation (ArtifactsAgent + SpecAgent): Upon approval, a SequentialAgent pipeline fires two specialized agents. The ArtifactsAgent produces ADRs and a PRD; the SpecAgent consumes that output to generate a detailed technical spec and up to 15 atomic development tickets ordered by layer (infrastructure → domain → API → frontend).
Asynchronous Execution: All agent work happens via message queues. The user can close the interface—Firebase's onSnapshot delivers live status updates the moment agents complete their work.
RAG Context: Each completed project generates an embedding (text-embedding-004). Future projects retrieve the top-3 similar past projects and inject that context into the agents' prompts, improving spec quality over time.

How we built it

Pyahu Scrum is built on Google's AI ecosystem, using the Google Agent Development Kit (ADK 2.8) as the core orchestration framework. To maximize cost-efficiency and keep cloud spending at zero during development, we adopted a hybrid architecture:

Multi-Agent Architecture: Three specialized LlmAgent instances collaborate via a SequentialAgent pipeline (OrchestratorAgent, ArtifactsAgent, and SpecAgent), using the output_key mechanism for reliable handoffs.
Intelligence Engine: Powered by Gemini 3.6 Flash via the Gemini API, providing the speed and context depth required to parse complex business logic across multiple agent turns.
Cloud-Native State & RAG (GCP): Google Cloud Firestore is the heart of the system. It persists all project state, elicitation history, generated artifacts, and RAG embeddings.
Cost-Optimized Asynchronous Infrastructure: To preserve GCP credits during the hackathon, the asynchronous event bus is temporarily handled by local Docker containers running RabbitMQ (with dedicated queues and DLQ for failure isolation). Each consumer thread validates project existence via Firestore before processing.
Frontend: React 18 + TypeScript, with a live landing page built using Remotion 4 that animates the full pipeline flow in an SVG diagram with real telemetry pulled from Firestore.

To ensure the RAG engine accurately maps new project ideas to historical documentation, relevance is calculated using cosine similarity:

$$\text{sim}(q, d) = \frac{q \cdot d}{\Vert{}q\Vert{} \Vert{}d\Vert{}} = \frac{\sum_{i=1}^{n} q_i d_i}{\sqrt{\sum_{i=1}^{n} q_i^2} \sqrt{\sum_{i=1}^{n} d_i^2}}$$

Challenges we ran into

The primary challenge was designing genuine Human-in-the-Loop control without breaking the asynchronous pipeline. Every agent action publishes to a queue and returns immediately—the UI reflects progress via onSnapshot. Inserting a mandatory human approval checkpoint between the interview phase and artifact generation required a new pipeline state (AGUARDANDO_APROVACAO_ESCOPO) and a feedback loop where the user's revision message re-enters the queue, prompting the model to decide whether to open a new interview round or refine the scope summary.

A second challenge was making the multi-agent handoff reliable. Ensuring the SpecAgent always received complete, structured output from the ArtifactsAgent inside the SequentialAgent pipeline required careful prompt design and fallback JSON parsing.

Accomplishments that we're proud of

We successfully built a true Taskmaster. We are most proud of the Human-in-the-Loop approval flow—it breaks the "chatbot illusion" by pausing autonomous execution at the moment it matters most, giving users real control over scope before irreversible documentation is generated. Additionally, the 3-agent ADK architecture gives each agent a single responsibility and typed output key, making the pipeline composable and testable. The seamless integration of ADK, Gemini 3.6 Flash, and Firestore produced a system that handles the full journey from raw idea to downloadable ZIP autonomously.

What we learned

We learned that the true power of next-generation agents lies in orchestration discipline and human checkpoints. A brilliant LLM is only as useful as the pipeline that surrounds it, and that pipeline is only trustworthy when humans remain in control of the decisions that matter. The ADK's SequentialAgent and LlmAgent primitives gave us the structure to enforce single-responsibility, while Firebase's onSnapshot eliminated the need for polling, making real-time multi-agent coordination feel natural.

What's next for Pyahu Scrum

With the core intelligence and Firestore state management proven, the next step is migrating the local RabbitMQ/Docker event bus to Google Cloud Pub/Sub and Cloud Run, establishing a fully serverless, enterprise-grade architecture. We also plan to add OpenTelemetry instrumentation to expose per-agent latency and token usage in a live dashboard, and to expand the ADK pipeline with a ReviewAgent that performs automated code review on tickets—moving Pyahu Scrum toward the Fortified Enterprise Fleet track.