-
-
-
-
Basic Agent Execution
-
CLITesting
-
-
Inspiration
Turning a business requirement into a working software solution is rarely a single task. It involves requirement analysis, architecture decisions, API design, implementation, testing, debugging, deployment, and validation. Today, these steps are often distributed across architects, developers, QA engineers, and DevOps teams. As a Technical Architect, I wanted to explore a different approach:As a Technical Architect, I wanted to explore a different approach: What if an AI agent could take the objective not just the prompt and actually complete the software delivery workflow? That question inspired ArchitectOps Agent. Instead of building another AI chatbot that explains how to build an application, ArchitectOps is designed to take ownership of the workflow. A user provides a natural-language business requirement, and the agent plans the work, generates a .NET API, creates tests, executes validation, analyzes failures, self-corrects when necessary, deploys the solution to Google Cloud, and validates the deployed service. The goal is simple: Move from "AI that tells developers what to do” to “AI that actually does the work.”
What it does
ArchitectOps Agent is an autonomous software delivery agent that transforms a natural-language requirement into a tested and deployed API. For example, a user can provide: Build an Order Management API that allows customers to create, retrieve, and cancel orders. Validate requests, persist order information, expose REST endpoints, include automated tests, and deploy the application to Google Cloud.
How we built it
ArchitectOps uses Google's agentic AI stack together with Google Cloud infrastructure. AI & Agent Framework Gemini 3.5+ — reasoning, planning, code generation, failure analysis, and decision making Google ADK — agent orchestration, tool integration, and execution workflow Google Cloud Cloud Run — hosts the agent backend and deployed application workloads Firestore — stores agent state, job information, execution history, and results Pub/Sub — supports asynchronous/background workflow execution Cloud Storage — stores generated artifacts when required Cloud Logging — provides execution and operational visibility Application Stack- Python — agent runtime React + TypeScript — web interface ASP.NET Core / .NET — generated application workloads REST APIs — communication between application components
Challenges we ran into
Making the Agent Truly Autonomous:One of the biggest challenges was determining where the LLM should make decisions and where deterministic software should execute the action. We designed a clear separation:Gemini decides what should happen. Tools determine how the action is executed.This provides greater control and makes the system easier to reason about. Handling Failures::Code generation is not guaranteed to produce a correct implementation on the first attempt. Instead of treating failures as the end of the workflow, ArchitectOps treats them as feedback. Build and test output becomes an observation that Gemini can analyze and use to determine the next action. Managing Long-Running Workflows: Software generation, testing, and deployment can take longer than a normal HTTP request. We therefore designed the workflow around persistent job state and asynchronous execution using Firestore and Pub/Sub. Controlling Agent Capabilities: Giving an LLM unrestricted access to development and deployment operations would create unnecessary security risks. We therefore designed tool boundaries and execution policies so the agent can only perform explicitly permitted operations within the intended workspace and environment.
Accomplishments that we're proud of
Built a truly agentic workflow rather than a traditional chatbot. ArchitectOps can take a high-level business requirement and autonomously plan and execute multiple software-delivery steps. Demonstrated the complete requirement-to-deployment journey. The agent can move from requirement analysis to .NET API generation, automated testing, failure analysis, correction, deployment, and validation. Implemented self-correction. Instead of stopping when generated code fails, the agent uses build and test results as feedback, reasons about the failure, modifies the implementation, and retries. Made the workflow asynchronous and stateful. Long-running agent executions can continue in the background while Firestore maintains job state, execution history, and results. Successfully connected AI reasoning with real engineering tools. Gemini is responsible for reasoning and decisions, while deterministic tools perform file operations, builds, tests, deployment, and health checks. Built on Google's agentic ecosystem. The solution combines Gemini 3.5+, Google ADK, and Google Cloud services such as Cloud Run, Firestore, and Pub/Sub into one end-to-end workflow. Focused on controlled autonomy. We designed explicit tool boundaries and execution controls so the agent can act autonomously without giving the LLM unrestricted access to the underlying environment. Most importantly, we demonstrated that an AI agent can be measured by the work it completes—not simply by the quality of the answer it generates.
What we learned
Building ArchitectOps changed our perspective on AI application development. The biggest lesson was that an agent is not simply an LLM connected to a few APIs. A useful agent requires: A clear objective ,Planning ,Tools, Persistent state, Observability. Feedback from the environment. Error handling. Guardrails The ability to iterate. We also learned that autonomy must be demonstrated through observable actions. Generating an impressive answer is easy to demonstrate.
Showing an agent generate an implementation, execute it, encounter a failure, reason about the failure, correct the implementation, redeploy it, and validate the result is a much stronger demonstration of agentic behavior.
What's next for ArchitectOps Agent
ArchitectOps can evolve beyond a single software delivery workflow. Potential future capabilities include: Multi-agent architecture and security reviews Automated architecture decision records Security and compliance analysis Infrastructure-as-code generation Cost estimation API contract generation Automated documentation CI/CD integration Enterprise approval workflows Policy-based deployment controls Additional Google AI models such as Gemma for independent review The longer-term vision is an AI-native software delivery platform where engineers define outcomes and autonomous agents execute the engineering workflow under controlled policies and human governance.
Log in or sign up for Devpost to join the conversation.