My Tech Stack: The Google-Native Architecture for the Agentic Era

Let’s be completely honest upfront: I am a Google fanboy.

When it comes to building my personal projects, software experiments, and AI tools, I don't try to juggle five different cloud providers, eight third-party SaaS tools, and whatever JavaScript framework is trending on Twitter this week.

I use Google for almost everything.

The biggest reason isn't complex theory—it's simply that when you use these tools together, everything feels remarkably clean, cohesive, and in sync. There is no fighting glue code, no juggling separate auth tokens across disjointed dashboards, and no friction when building autonomous AI agent workflows.

Here is how my core stack fits together, why I love each piece, and why it just clicks for my personal builds.

---

1. Protecting Flow State & Solo Builder Momentum

When you build things solo, momentum is everything. My mind moves fast, non-linearly, and abstractly. When I am in a hyperfocused creative flow, nothing kills the spark faster than unexpected friction—fighting npm version mismatches, hunting down expired auth tokens, or debugging third-party middleware.

Going all-in on a unified, Google-native ecosystem protects that flow state:

The Developer Cockpit: Google Antigravity

I don’t want a chat box floating next to my code; I want an agentic partner. Built as a specialized fork of VS Code, Antigravity gives me an environment where Gemini can pair-program, run terminal commands, and refactor across files autonomously in the background while I stay focused on high-level ideas.

Because it's natively integrated with Gemini's massive 1M–2M+ token context window—and with plenty of credits included on my Google AI Ultra plan (I can code practically nonstop each week and have only hit the weekly limit once or twice)—the IDE natively understands my entire codebase and project files without me needing to configure anything.

The Runtime Engine: ADK (Agent Development Kit)

For orchestrating autonomous multi-agent systems, I use ADK. It gives me clean, code-first workflows without having to fight bloated third-party agent libraries, and it shares the exact same tools and mental models as Antigravity.

The Memory Backbone: The Agentic Data Lakehouse (BigQuery)

BigQuery isn't just an analytics warehouse to me anymore—it has become the active memory, grounding layer, and reasoning engine for my autonomous agents.

When Google announced the Agentic Data Lakehouse at Google I/O this year, I set it up for myself—and the experience has been incredible. Connecting Antigravity directly to the BigQuery MCP and leveraging conversational analytics tools lets my AI agents introspect database schemas, write and execute analytical queries, and reason over multi-terabyte datasets in place without maintaining brittle custom ETL pipelines. It fundamentally changes how you interact with data when your agents can explore and converse with your lakehouse directly.

The Fast Operational Base: Firebase

When I have an idea for an app or tool, Firebase gets me from zero to live in minutes. Instant authentication, real-time document storage (Firestore), security rules, and App Hosting. It takes care of all the plumbing so I can focus on building.

The Predictable UI Layer: Angular

In an era where AI agents write more and more frontend code, framework strictness is a superpower. Angular's opinionated, structured nature gives agents clear guardrails. While React lets agents solve the same problem ten chaotic ways, Angular enforces one clear pattern—ensuring the code stays clean, consistent, and predictable.

---

2. In the Back of My Mind: The Closed-Loop AI Supply Chain

While day-to-day developer flow is my main motivation, there is also a quiet, reassuring thought in the back of my mind: Google's vertically integrated AI foundation.

Google wrote a fantastic breakdown on Ironwood, their latest custom TPU and their dedicated Cloud TPU architecture. Unlike most AI companies that rent hardware from one vendor, run on someone else’s cloud, and stitch together third-party models, Google owns the whole stack from the silicon up:

• Custom Silicon (Ironwood): Designing their own custom TPUs and global data center infrastructure.
• Frontier Models: Gemini trained and served natively on that custom hardware.
• Developer & Cloud Tools: Antigravity, BigQuery, and Firebase built to interface natively with those models.

Knowing that the tools I use are backed by an end-to-end, closed-loop supply chain gives me long-term confidence that the platform is durable, performant, and built to last.

---

3. The Myth of "Vendor Lock-In": Open Standards Under the Hood

A common question people ask is: "Aren't you worried about locking yourself into a single vendor?"

What I appreciate most about Google's modern ecosystem is that it is built on top of open, portable standards:

• Apache Iceberg: Open table formats for BigQuery storage so your data is never locked into a proprietary silo.
• Model Context Protocol (MCP): Open standard protocols for agent tools and context.
• Angular & TypeScript: Standard, open-source web foundations.

You get the supreme speed and cohesion of a single platform without being trapped in closed proprietary formats.

---

4. Pure Serverless Economics: The $0 Idle Stack

As an independent builder running lots of experiments, you don't want a dozen idle servers silently billing you hundreds of dollars each month.

The beauty of this architecture is pure serverless economics:

• Cloud Run: Scales down to zero instances when traffic stops.
• Firebase App Hosting: Scales dynamically to zero runtime cost when idle.
• BigQuery: On-demand query pricing where you only pay when you actually compute.
• Firestore: Generous free quotas for personal applications.

My personal experiments and prototypes sit happily in the cloud for $0/month when idle, only consuming resources when I actively run an agent workflow or open an app.

---

5. Cohesion Over Chaos

Could I swap out parts of this stack for other tools? Sure. But every external tool you add introduces glue code, separate billing dashboards, auth token juggling, and maintenance fatigue.

By committing to a cohesive, Google-native ecosystem:

• The IDE (Antigravity) understands the cloud (GCP).
• The AI agents (ADK) share the same tools and context as the developer.
• The operational database (Firestore) streams directly into the analytical memory (BigQuery).
• The frontend (Angular) deploys effortlessly via Git to the hosting layer (Firebase App Hosting).

It feels clean, coherent, and built for where the future of software and autonomous agents is heading.

---

This is a living note (currently in 🌿 Bud stage). In upcoming posts, I'll be sharing deeper walkthroughs and practical experiments from my personal builds across each of these tools.

Explore related thoughts in Welcome to my digital garden and From Gemini Chats to Signals.