Forem: Michael G. Inso

Securing the Autonomous Future with Auth0 Token Vault for AI Agents

Michael G. Inso — Mon, 23 Mar 2026 18:23:21 +0000

As developers, we are living through a massive paradigm shift. We are no longer just building applications for human users; we are building ecosystems for autonomous AI agents. But this shift introduces a terrifying security gap. How do we give an AI agent the keys to execute a payment on Stripe or commit code to GitHub without hardcoding API keys or granting god-level access?

During this hackathon, I set out to solve this exact problem by building the Auth0 Token Vault Marketplace—a platform powered directly by the brand new Auth0 Token Vault for AI Agents.

The Problem with Traditional API Keys

Before Auth0’s AI Agent Vault, if an AI needed to interact with a third-party service, developers usually resorted to passing static, long-lived API keys into the agent's context. This is fundamentally insecure. If the agent's prompt is hijacked or logs are leaked, that static key is compromised indefinitely. Traditional OAuth flows weren't designed for machines; they were designed for humans clicking "Authorize" in a browser window.

How We Leveraged Auth0 Token Vault

Instead of handling raw keys, our application uses the Auth0 Token Vault to act as a secure, intermediary broker. When an AI agent needs to perform a task within our marketplace, it doesn't use a static .env credential.

Instead, the agent authenticates with Auth0 to request a delegated, short-lived access token specifically scoped for that exact transaction.
Here is how we utilized it to achieve maximum security:

Scope Limitation: If an AI agent only needs to read a user's marketplace balance, Auth0 ensures the token generated only has read:balance permissions. It cannot execute trades or revoke existing credentials.
Ephemeral Lifespans: The tokens issued by the Vault to the AI expire quickly. Even if intercepted, the attack window is negligible.
Auditability: Because every AI transaction goes through Auth0, we have a complete, centralized audit trail of exactly which AI agent requested access, when, and for what purpose.

Why This Matters for the Auth0 Community

The Auth0 community has long been the gold standard for human identity management. By integrating the Token Vault for AI Agents into a functional marketplace, we've demonstrated how Auth0 is positioning itself to be the gold standard for machine identity management.

We built the frontend with React 19, TypeScript, and GitHub Spark to visualize this secure backend infrastructure. By wrapping the Auth0 Token Vault inside a beautifully designed, cyber-punk-themed React application, we proved that enterprise-grade security for AI doesn't have to be clunky or invisible. It can be a dynamic, measurable, and highly controllable asset class of its own.

The future of software is agentic. Thanks to the Auth0 Token Vault, that future is also secure.

The "Secret Zero" Problem in the Age of Autonomous AI

The rapid rise of AI agents has introduced a critical security vulnerability into modern software architecture: machine credential management. Traditionally, to grant an LLM or AI agent access to external services—like making a payment via Stripe or committing code to GitHub—developers have resorted to passing raw, long-lived API keys directly into the agent's runtime environment or context window. This fundamental flaw violates the principle of least privilege, bypasses standard Identity and Access Management (IAM) protocols, and exposes enterprise infrastructure to devastating risks like prompt injection and agent hijacking.

We needed a paradigm shift. We needed to stop treating AI agents as scripts holding master keys, and start treating them as first-class, verifiable identities.

Enter Auth0 Token Vault for AI Agents

Integrating the Auth0 Token Vault for AI Agents into the Auth0 Token Vault Marketplace was my core technical achievement for this hackathon, as it fundamentally solves the agentic "Secret Zero" problem. Auth0's Token Vault acts as a highly secure, ephemeral credential broker. Instead of a developer hardcoding a credential, the Auth0 infrastructure holds the root connection securely. When the AI agent needs to act, it dynamically requests a just-in-time, scoped token from the Vault.

My technical implementation focused on bridging Auth0's rigorous, enterprise-grade backend security with a highly responsive, client-side architecture built on React 19, TypeScript, and GitHub Spark.

While GitHub Spark’s persistent key-value store (spark.kv) was used to manage the complex application state—such as user wallet balances, UI micro-interactions, and the linear-decay marketplace pricing models ($V(t)$)—the actual cryptographic lifecycle of the tokens was strictly deferred to Auth0. By decoupling the marketplace ledger (Spark) from the identity provider (Auth0), I achieved a hybrid architecture: the frontend handles the dynamic API economy, while Auth0 guarantees that the underlying credentials are mathematically bound, time-limited, and scope-restricted.

Relevance to the Auth0 Community

For the Auth0 developer community, this project serves as a practical blueprint for the "Zero-Trust Agentic Web." As the community builds increasingly complex, multi-agent systems, standard human-centric OAuth/OIDC flows are no longer sufficient. Machine-to-Machine (M2M) delegation requires dynamic credential brokering.

By integrating the Token Vault into a visual, interactive marketplace, I demonstrated that Auth0’s infrastructure can be used for more than just compliance and security—it can serve as the foundational trust layer for a new AI API economy. Developers can actively allocate, trade, and monitor agent access quotas with complete confidence. Ultimately, the Auth0 Token Vault for AI Agents doesn't just secure our current applications; it fundamentally enables the next generation of autonomous software to operate safely at an enterprise scale.

Moneyball Coach AI: Building a Real-Time Esports Analytics Platform with Next.js and GRID API 🎮📊

Michael G. Inso — Mon, 02 Feb 2026 13:15:02 +0000

The "Moneyball" Moment for Cloud9

In the movie Moneyball, Billy Beane changed baseball forever by ignoring gut feelings and trusting the data. He looked for the hidden stats that actually led to wins.

For this hackathon, we asked ourselves: Can we build a "Billy Beane" for Cloud9?

Esports is digital-native, yet so much coaching is still done via spreadsheets and VOD review. We wanted to change that. Enter Moneyball Coach AI, a comprehensive analytics platform that processes live match data to deliver real-time insights, player performance tracking, and strategic win-probability models.

Here is the story of how we built a 96% TypeScript application to turn raw data into victory.

🏗️ The Tech Stack

We needed a stack that could handle high-frequency data updates without stuttering. Speed was our top priority.

Framework: Next.js (App Router)
Language: TypeScript (96.8% of the repo!)
Data Source: GRID Esports API
State Management: Zustand + TanStack Query
Visualization: Recharts
Styling: Tailwind CSS (Cloud9 Theme)

🔌 Integrating the GRID API

The heartbeat of our application is the GRID API. It provides an incredible depth of data, but that depth comes with complexity. A single match can generate thousands of events—gold changes, positional updates, item purchases, and ability usage.

Our biggest challenge was Type Safety. The JSON objects from GRID are deeply nested. We didn't want to use any; we wanted strict typing to prevent runtime crashes.

We created a robust schema to normalize this data:

// Example Interface for Normalized Player Data
interface PlayerMetric {
  summonerName: string;
  championId: number;
  currentGold: number;
  visionScore: number;
  laneProximity: number; // Calculated metric
  winProbabilityContribution: number; // AI Model output
}

By strictly defining these interfaces, our IDE (VS Code/WebStorm) could autocomplete properties and warn us if we tried to access a null value—a lifesaver during the final hours of the hackathon!

🚀 Handling the "Firehose" of Data

One of the coolest technical hurdles we cleared was the "Firehose Effect."

When a team fight breaks out in-game, the API sends a burst of events. If we tried to update the React DOM for every single event, the dashboard would freeze.

We solved this using a Buffering Strategy and Optimistic UI.

Ingestion: We catch the websocket stream.
Batching: We group events into 500ms "ticks."
React Query: We use useQuery to fetch the stable state, while a custom hook applies the "tick" updates instantly for a smooth visual experience.

This created a "Glass-to-Glass" latency that feels instantaneous to the user.

🧠 The "Moneyball" Insight

The core feature we are most proud of is the Efficiency Engine.

Instead of just showing "Kills" (which can be a vanity metric), our algorithm calculates Gold Efficiency.

If a player has 10,000 gold but hasn't spent it, they are statistically weaker than an opponent with 8,000 gold all spent on items.

We visualized this on our dashboard. If a Cloud9 player is holding too much gold before a crucial dragon fight, the dashboard flashes a warning. This is the kind of actionable data that helps coaches make real-time calls.

🎨 Designing for the Pros (The Cloud9 Aesthetic)

We didn't just want it to work; we wanted it to look like it belonged in the Cloud9 HQ.

We used Tailwind CSS to strictly enforce the team's identity.

Primary: bg-slate-900 (Dark Mode default)
Accent: text-cyan-400 (Electric Blue)
Visuals: We used backdrop-blur effects on our data cards to give them a futuristic, "heads-up display" feel.

🛠️ Tooling Spotlight & Bonus Challenges

⚡ Scaling a 96% TypeScript Esports Platform with WebStorm

📖 The Story
"Building Moneyball Coach AI required handling massive, deeply nested JSON objects from the GRID API in real-time. We chose JetBrains WebStorm as our primary IDE, and it was instrumental in maintaining our 96.8% TypeScript codebase."

✅ Completeness & Viability
The most impactful feature was WebStorm's deep static analysis and refactoring capabilities. When defining the complex interfaces for the GRID API live streams, we frequently had to refactor types across our Next.js backend and React frontend. WebStorm’s 'Rename Symbol' and 'Find Usages' worked flawlessly across the full stack, catching type mismatches that VS Code plugins often missed.

🚀 Potential Impact
Furthermore, the integrated AI Assistant helped us generate boilerplate code for our Recharts visualizations, saving us hours of manual coding. The debugger's ability to handle high-frequency state changes in our useLiveStream hooks allowed us to isolate race conditions in the data pipeline much faster than standard browser tools. WebStorm didn't just write code; it acted as a stability guardrail for our high-velocity development.

🛡️ Optimizing Real-Time Data Streams with Junie

📖 The Story
"For Moneyball Coach AI, we built a high-performance dashboard that ingests thousands of events per second via the GRID API. We utilized Junie to audit our code quality and ensure our complex logic remained performant."

🔍 Completeness & Viability
Junie provided critical insights into our React rendering patterns. Since our dashboard updates in real-time, preventing unnecessary re-renders is crucial. Junie analyzed our custom hooks and flagged dependencies in useEffect and useMemo that were causing performance leaks—issues we hadn't caught during manual review. It also helped identify potential null-reference errors in our deep-nested API response handling.

⚡ Potential Impact
The feedback provided by Junie was directly actionable. By implementing its suggestions, we noticed a smoother frame rate on our live graphs. For a hackathon project where speed is everything, having an automated code reviewer that understands modern TypeScript patterns allowed us to ship a production-grade 'Moneyball' experience without getting bogged down in technical debt.

🏁 What We Learned

Building Moneyball Coach AI taught us that Context is King.

Raw data is useless without context. Telling a coach "Blaber has 5 kills" is okay. Telling a coach "Blaber's pathing is 15% more efficient than the enemy jungler, leading to a 60% higher win probability" is game-changing.

We pushed the limits of what Next.js can do with real-time data, and we can't wait to keep refining our models.

GG WP! (Good Game, Well Played)

Check out the code on GitHub: MiChaelinzo/moneyball-coach-ai-p

Test the Web-app on GitHub: View Live Demo

⚡ How We Built a Pro-Level Esports Aim Trainer with React 19 & GPT-4o

Michael G. Inso — Sun, 01 Feb 2026 20:24:05 +0000

Here is a polished, high-quality blog post draft formatted for platforms like Medium, Dev.to, or Hashnode. It balances technical depth with storytelling to maximize your chances of winning the bonus prize.

⚡ How We Built a Pro-Level Esports Aim Trainer with React 19 & GPT-4o

Behind the code of "C9 Reflex Arena"—our Cloud9 x JetBrains Hackathon entry.

![Cover Image Placeholder: A split screen showing code on the left and the glowing neon game interface on the right]

In the world of esports, the difference between a highlight reel and a "gray screen" is measured in milliseconds. When Cloud9 and JetBrains announced a hackathon to build the ultimate fan engagement experience, we knew we couldn't just build a simple clicker game. We needed something that felt competitive, looked cyberpunk, and ran at a buttery smooth 60 FPS.

Enter C9 Reflex Arena: An adaptive reaction training ground designed for the chaotic energy of an LCS event booth.

Here’s a deep dive into how we built it using the absolute bleeding edge of web tech: React 19, Tailwind CSS v4, and AI-driven game design.

🏗️ The Stack: Living on the Edge

We decided to take a risk. Instead of using the "safe" stack, we wanted to see what the future of frontend development looked like.

Framework: React 19 (RC)
Styling: Tailwind CSS v4 (Alpha)
State: Spark KV + Functional Updates
AI: OpenAI GPT-4o-mini (via Vercel AI SDK)
IDE: WebStorm 2024.3 with Junie

Why React 19?

We wanted to leverage the new Compiler and Action paradigms. In a high-frequency game loop, re-renders are the enemy. React 19 allowed us to manage complex state transitions (score, combo, timer, particle count) without the "useEffect hell" that usually plagues React games.

🧠 The Secret Sauce: AI Adaptive Difficulty

Most reaction games have static difficulty settings: Easy, Medium, Hard. We wanted C9 Reflex Arena to feel like a living opponent.

We integrated GPT-4o-mini to analyze player telemetry in real-time. The game doesn't just spawn targets; it watches you.

How it works:

Data Collection: The game tracks your average reaction time (ms) and accuracy (%) over a 10-target window.
The Prompt: We send this batch data to the AI with a system prompt: "You are an esports coach. The player is hitting 95% accuracy with 150ms reaction time. Adjust the game parameters to challenge them without frustrating them."

JSON Response: The AI returns structured JSON:

{
  "spawnInterval": 450,
  "targetSize": 0.85,
  "message": "Too easy? Let's speed it up."
}

Hot-Patching: The game state updates instantly. If you’re playing like a pro, the targets get smaller and faster. If you miss three in a row, the game slows down to help you recover your rhythm.

🎨 Styling with Tailwind v4

Tailwind v4 is a paradigm shift. Gone is the massive configuration file; everything is now native CSS variables. This was crucial for our Theme Engine.

We defined our "Cloud9 Cyberpunk" palette using OKLCH colors for maximum vibrancy on gaming monitors:

:root {
  --color-c9-blue: oklch(0.65 0.24 240);
  --color-c9-pink: oklch(0.70 0.25 350);
}

Because v4 compiles on the fly, we could animate these variables using Framer Motion to create pulsating neon glows that react to the beat of the game without causing layout thrashing.

🤖 Coding with Junie (JetBrains AI)

Since this was a JetBrains hackathon, we leaned heavily on Junie, their new AI agent in WebStorm.

Honest review? It saved us about 30% development time.

The "killer feature" wasn't code generation—it was Contextual Refactoring. At one point, our GameCanvas.tsx file hit 600 lines. We asked Junie: "Extract the particle rendering logic into a custom hook."

Junie didn't just give us the code snippet; it analyzed the dependencies, created useParticleSystem.ts, moved the relevant useRef hooks, and updated the imports in the parent file. For a hackathon timeline, that kind of automated refactoring is invaluable.

🚀 The Result

C9 Reflex Arena is now a fully functional PWA (Progressive Web App). It features:

Global Leaderboards (GitHub Auth)
Friend Challenges (Async competition)
60 FPS Performance on mobile and desktop
Event Ready Mode for fast booth turnover

Building this project taught us that the web is ready for high-performance gaming. React 19 handles the logic, Canvas handles the rendering, and AI handles the balance.

The code is open source. If you want to see how we wired up the AI or how Tailwind v4 works in production, check out the repo below!

*🔗 https://github.com/MiChaelinzo/untitled *
*🎮 https://untitled--MiChaelinzo.github.app *

Built with 💙 for the Cloud9 x JetBrains Hackathon.

React19 #Cloud9 #JetBrains #Hackathon #WebDev #AI

I Built a Deckbuilder Game Engine with Kiro: From Specs to "Slay the Spire"

Michael G. Inso — Mon, 01 Dec 2025 16:08:42 +0000

🃏 The Dream: Building "Chambers"

Like many developers, I’ve always been fascinated by the mechanics behind games like Slay the Spire. The synergy between cards, the economy of a shop, and the tension of a reshuffle—it’s a beautiful system. But from a coding perspective, it’s a nightmare of state management.

How do you handle a Discard Pile shuffling into a Draw Pile mid-turn without losing data? How do you ensure "Damage" is calculated correctly through 5 layers of status effects?

I decided to build Chambers, a survival deckbuilder. But instead of slogging through spaghetti code, I used Kiro, an agentic IDE, to architect the system for me. Here is how Kiro changed my development process from "guessing" to "architecting."

🏗️ Phase 1: The "Spec-First" Approach

Usually, when working with AI, we just start chatting: "Write me a card script." This often leads to disjointed code. With Kiro, I used Spec-Driven Development (SDD).

I didn't write code first. I wrote rules.

Inside the .kiro/ directory, I created a "Source of Truth" for my game logic. I described the Deck lifecycle in natural language:

Spec Excerpt:
"When the Draw action is requested, checking if the Draw Pile is empty. If so, shuffle the Discard Pile, move it to the Draw Pile, and then complete the draw. Ensure no card objects are duplicated or lost during the transfer."

Kiro read this spec and generated a robust TypeScript framework. It didn't just write a script; it built a system that adhered strictly to my rules. This meant my core game logic was decoupled from the game engine—pure, testable code.

🤖 Phase 2: Kiro as a QA Engineer (MCP & TDD)

This is where Kiro shined. I didn't want to debug shuffle logic inside the Unity Editor (which is slow). I wanted to verify the math instantly.

Using Agent Hooks and MCP (Model Context Protocol), I set up a "Self-Healing" workflow:

Kiro implements a feature (e.g., Shop.buyCard()).
Kiro automatically triggers npm test via the terminal.
If the test fails, Kiro reads the error log, analyzes the stack trace, and refactors the code immediately.
If the test passes, it moves to the next task.

It felt like pair-programming with a Senior Engineer who loves writing unit tests. By the time I opened Unity, I knew my logic was 100% bug-free.

🧠 Phase 3: The Hybrid Architecture (Node.js + Unity)

One of the hardest parts of this project was preventing "Language Contamination." I needed Kiro to write TypeScript for the logic and C# for the Unity frontend.

I leveraged Steering to give Kiro a split personality:

The Brain (Framework): "You are a Node.js architect. You do not know Unity exists. Focus on pure data structures."
The Body (Unity): "You are a Unity developer. You do not calculate damage. You only visualize the state provided by the framework."

This separation of concerns prevented the dreaded "Spaghetti Code" where UI logic mixes with game rules.

🌊 Phase 4: Vibe Coding the Polish

Once the hard math was done via Specs, I switched to Vibe Coding for the visuals. This was the fun part.

I chatted with Kiro to tweak the "feel" of the game:

"Make the cards hover when the mouse is over them."
"Add a particle effect when an enemy takes damage."

Because the logic was already solid, we could iterate on the visuals rapidly without breaking the game loop.

🚀 The Result

Chambers is now live and playable. It features a fully functional battle loop, a shop economy, and a robust deck-building system.

What I learned:
AI isn't just for writing boilerplate. If you use tools like Kiro to define Specs and enforce Tests, you can build complex, architectural software that is actually maintainable.

Play the Game: Unity Play Link
Check the Code: GitHub Repository

Give Kiro a try if you want to stop fixing bugs and start building systems.

From Text to Live Video: How We Built a Serverless Multimodal Logistics AI on Google Cloud Run

Michael G. Inso — Sat, 08 Nov 2025 13:38:31 +0000

The logistics industry runs on information. From tracking numbers on a crumpled label to complex terms in a PDF contract, the speed and accuracy of communication can make or break a shipment. So, for a recent hackathon, my team decided to tackle this challenge head-on. Our goal? To build an intelligent assistant that could understand and assist with logistics queries, no matter how they were presented.

The result was the World Movers AI Agent, a multimodal assistant that can chat, read documents, analyze images, understand voice commands, and even interpret live video from a webcam or screen share.

Here’s a look at how we built this powerful, scalable AI application using the magic of Google Cloud Run and Google's Gemini models.

The Vision: An AI That Sees and Hears

We didn't want to build just another chatbot. We envisioned a true "agent" that could interact with the world in the same ways a human does. Our core feature list looked like this:

Smart Conversations: Handle text-based questions about services, quotes, and support.
Document Analysis: Upload a PDF, DOCX, or TXT file and ask questions about its contents.
Image Recognition: Analyze images of shipping labels, cargo, or warehouse scenes.
Voice Commands: Speak directly to the agent for hands-free interaction.
Live Analysis: Use a webcam or screen share to get real-time feedback and support.
Actionable AI: Go beyond answering questions by taking action, like compiling and emailing a quote request to the sales team.

Why Google Cloud Run was a No-Brainer

To build this, we needed a platform that was fast, scalable, and let us focus on the AI logic, not infrastructure. Google Cloud Run was the perfect fit.

Serverless Simplicity: As a small hackathon team, we didn't have time for server provisioning or management. With Cloud Run, we just packaged our code in a Docker container and deployed it. Google handles the rest.
Scale to Zero (and to Infinity): This is a killer feature. When our app wasn't being used, it automatically scaled down to zero instances, meaning we weren't paying for idle time. But if we suddenly got a surge of users, Cloud Run would instantly scale up to handle the load.
Container-Powered: Using Docker meant our development environment was identical to our production environment. This eliminated the classic "it works on my machine" problem and made deployment a breeze.

Our Architecture: A Tale of Two Services

We kept our architecture clean and simple, leveraging two distinct Cloud Run services:

frontend-service: A very lightweight service whose only job was to serve our static web interface (built with HTML, CSS, and JavaScript). This is what the user sees and interacts with.
backend-api-service: This was the brains of the operation. A Python application (using the FastAPI framework) running as a separate Cloud Run service. It handled all the heavy lifting:
- Exposing an API that the frontend could call.
- Processing all incoming data, whether it was text, an uploaded file, or a video frame.
- Orchestrating the calls to our AI models on Google's Vertex AI platform.
- Sending the final, AI-generated response back to the user.

This separation of concerns made our application clean, scalable, and easy to manage.

The Magic Ingredient: Google's Gemini Models

Our agent's intelligence comes from Google's powerful Gemini models, which we accessed via the Vertex AI API:

Gemini Pro: This was our workhorse for all language-based tasks. It powered the chat conversations, summarized uploaded documents with incredible accuracy, and helped parse user intent.
Gemini Pro Vision: This is where the real magic happened. Gemini Pro Vision is a true multimodal model, meaning it can reason across text, images, and video. It's what allowed our agent to:
- Read the tracking number from a photo of a shipping label.
- Describe the contents of a user's shared screen.
- Identify a "shipping container" when held up to the webcam.

Crafting the prompts to combine these different data types was a fun challenge, but the results were astounding.

From Chatbot to "Agent": Taking Action

The defining moment was implementing the quote request workflow. A user can simply type, "I need a quote to ship a package." The AI, powered by Gemini Pro, understands this intent and asks follow-up questions like "What are the dimensions?" and "Where is it going?".

Once it has the necessary info, it doesn't just stop. It formats the data and triggers an API call to an SMTP service, sending a professional email directly to the sales team's inbox. This transforms the AI from a passive information source into an active participant in the business workflow.

Final Thoughts

Building a powerful, multimodal AI application is more accessible than ever. By combining the serverless power of Google Cloud Run with the incredible reasoning capabilities of Google's Gemini models, our small team was able to create a sophisticated logistics agent in a matter of days.

This project proved to us that the future of AI is multimodal, and the future of deploying it is serverless.

All-in-one Cryptocurrency CyberMatrix Analytics Cloud Run 💹🪙

Michael G. Inso — Fri, 07 Nov 2025 13:27:37 +0000

Unifying crypto metrics, real-time analytics, and secure cloud power—CyberMatrix delivers seamless, all-in-one insights for the future of cryptocurrency management. 📊📈

💱 Inspiration

The explosive growth of stablecoins and the cryptocurrency market shows the world needs real-time, intelligent analytics. Inspired by PayPal’s PYUSD and new digital asset innovation, we envisioned a universal dashboard for everyone—small businesses and pro traders alike. We fused Google Gemini AI, fast news sentiment, and persistent storage via MongoDB to deliver actionable, contextual analytics. The “AI in Action” hackathon spotlighting Google Cloud, MongoDB, and GitLab was the catalyst for our CyberMatrix platform.

🛰️ What it does

CyberMatrix Analytics Dashboard v2.1 is an all-in-one cloud solution for multi-chain crypto analytics, powered by Streamlit on Google Cloud Run:

Efficient Event Feeds: Track transactions (PYUSD, USDT, USDC, more), mint/burns, and smart contract events with fast MongoDB caching + GCP Blockchain RPC.
In-depth Analysis: Volume, tagged address leaderboards, and asset flow networks via MongoDB and GCP.
Historical Exploration: Explore events across block ranges—on-demand from cache or live blockchain.
Blockchain Tools: Address balances, persistent MongoDB watchlists, contract states, transaction lookups.
AI-Powered Insights (Gemini): Built-in AI assistant answers questions, surfaces news sentiment, and generates actionable summaries.
Contextual News: Real-time news feeds from NewsAPI, stored/searchable.
Innovative Simulation: Simulate bio-implant crypto payments to test future fintech concepts.
User Perks: One-click CSV export, custom UI, emoji-rich theming.

🌌 How We Built It

Tech Stack:

Frontend/UI: Streamlit dashboard
Data: MongoDB Atlas + PyMongo for storage
Cloud: Google Cloud Run (serverless, scalable)
- Cloud Build & Artifact Registry for CI/CD
- Secret Manager for keys/secrets
- Blockchain Node Engine for Ethereum RPC
- Gemini API for AI
Blockchain: Web3.py for live data
External Data: NewsAPI for crypto news
Visualization: Pandas, Plotly, Pyvis
Version Control: GitLab auto-builds

📡 Challenges we ran into

IAM Permissions: Cloud IAM tuning—deployment-blocking without precise roles.
Resource Management: RAM/CPU balancing for analytics, avoiding timeouts.
Schema Design: MongoDB schemas for events/news/watchlists optimizing speed/reliability.
RPC Fallbacks: Cache-first/fallback logic keeps data instant.
Performance: Query and indexing optimization for feeds.
Previous Issues: ABI quirks, Streamlit state, Gemini prompt engineering.

🪐 Accomplishments we’re proud of

End-to-End Deployment: Dockerized, CI/CD pipeline, encrypted secrets runtime.
MongoDB Power: Fast caching/search for analytics and persistent user settings.
News Indexing: Near-instant news storage/search.
Persistent Watchlists: Watchlists persist across logins/sessions.
Hybrid Fetch Model: Smart cache + RPC fallback data fetching.
Actionable AI: Gemini powers fast sentiment/analysis.

🤖 What we learned

Cloud Build Skills: Code-to-deploy Docker builds.
Secret Hygiene: Safe secret management with Google Secret Manager.
IAM Deep Dive: Role/service account security.
Dockerization: Reproducible dev environments.
Schema Skills: MongoDB indexing/schema design for analytics.

🚀👨🏻‍🚀 What's next for CyberMatrix Analytics

Stablecoin Expansion: Add USDT, USDC, DAI (cross-chain support).
Vector Search: Transaction/news embeddings in MongoDB for semantic search.
Advanced Aggregation: MongoDB upstream analytics for richer stats.
Live Sync: MongoDB Change Streams for real-time updates.
BigQuery Integration: Offload big data to BigQuery, keep MongoDB for live ops.
Personalized Accounts: Secure sign-in, custom dashboards, encrypted storage.
Zero Ops CI/CD: GitLab push-to-deploy—fully automated.

🧠 From Specs to Sentience: How Kiro IDE Helped Me Build a Reactive AI Dungeon in Days

Michael G. Inso — Thu, 14 Aug 2025 10:18:47 +0000

🛠️ The Spec-Driven Revolution

Everything began with a folder: /.kiro. Inside it, I wrote YAML specs for quests, NPCs, and global events. No hardcoded logic. No brittle managers. Just clean, declarative design:

- id: "neon_escape"
  startCondition:
    roomEntered: true
  endCondition:
    player.healthBelow: 0.2
  actions:
    spawn: "gangAmbush"
    reward:
      type: "neonShard"
      amount: 5

Kiro parsed these specs and instantly generated:

C# classes (QuestDefinition, EventTrigger)
YAML ↔ runtime serializers
Unity bindings that made everything playable on save

🤖 Agent Hooks That Think Ahead

I wired custom Kiro hooks to automate everything:

Saving a spec regenerated the quest pipeline
Creating an NPC archetype scaffolded AI behaviors and animation states
Dropping a prefab rebuilt the spawn registry and loot tables
Running a profiling hook injected performance throttles directly into the spec

It felt like having a full-time systems engineer working behind the scenes — except it was all AI.

✨ AI Pair Programming That Actually Works

I sketched my ideas in plain English:

“Build a map generator that carves rooms, places doors, and sets neon lighting.”

Kiro returned a complete C# class with:

Breadth-first room expansion
Adjacency checks
Weighted loot tables
Coroutine-driven lighting transitions

It compiled and ran on the first try. I didn’t touch a single boilerplate line.

🚀 What’s Next

Multiplayer sync via agent hooks
A player-authored spec editor
An open modding toolkit for infinite cyberpunk adventures

Kiro didn’t just accelerate development — it changed how I think about building games.

Specs are now my source of truth. AI is my co-creator. And iteration is instant.

Let’s build smarter worlds — one YAML file at a time.

🚇 How Kiro IDE Supercharged NeonQuest: From YAML Specs to Dynamic Cyberpunk Dungeons

Michael G. Inso — Mon, 28 Jul 2025 19:44:40 +0000

🎇 The Spark — Why NeonQuest Exists

I was instantly drawn to Daelonik’s Neon Underground asset pack — the luminous pipes, rain‑slick alleys, and that feeling of infinite space lurking just past the shadows.

But visual beauty wasn’t enough. I wanted true replayability: quests, NPCs, lighting, and ambiance that would shift dynamically based on a player’s actions and stats.

Hard‑coding that reactive logic would’ve been a long, brittle grind… until I discovered what Kiro could do.

🛠 Spec‑Driven Development, Supercharged

Instead of building managers and data classes by hand, I kept everything in human‑readable YAML under /.kiro:

# quests.yaml
- id: "escape_maze"
  startCondition:
    roomEntered: true
  actions:
    spawn: "gangAmbush"
    reward:
      type: "neonShard"
      amount: 5
  metadata:
    difficulty: medium

Kiro parsed these specs and instantly generated:

C# QuestDefinition classes
YAML ↔ runtime serializers/deserializers
Event‑binding logic that plugged quests straight into Unity’s update loop

Changing drop rates, difficulty, or spawn triggers became as simple as saving a file — no plumbing, no forgotten registrations. Just instant iteration.

🤖 Agent Hooks — Automation That Feels Like Magic

I wired custom agent hooks so common dev actions became runtime‑ready updates:

Spec Save → Full quest pipeline + event bindings regenerated instantly
New NPC Archetype → Auto‑scaffolded MonoBehaviour stubs, animations, and metadata
Asset Import → Spawn registry + loot tables rebuilt so the new prefab appeared in‑game on the spot

Every spec edit, every asset drop, every NPC definition — instantly live, perfectly synced, zero manual wiring.

✏️ Inline AI Coding & Multimodal Chat

To prototype complex systems, I talked to Kiro like a teammate:

“Build a ProceduralMapGenerator that carves rooms, places doors, and runs neon lighting coroutines.”

Within seconds, Kiro returned a full C# class featuring:

Breadth‑first room expansion
Overlap‑safe adjacency checks
Weighted loot distribution
Integrated event dispatcher for reactive encounters

It compiled and worked on the first try — what would’ve been hours of manual scripting just… appeared.

💡 Lessons That Stuck

Clarity powers creativity — well‑defined specs produce richer procedural outcomes.
Performance belongs in the loop — profiling hooks that auto‑inject throttles kept the experience silky‑smooth.
Fearless iteration wins — with boilerplate gone, I could spend all my cycles on world‑building and atmosphere.

🚀 What’s Next

🌐 Multiplayer sync layer — networked hooks that keep events consistent across clients.
✍ Player‑authored spec editor — so anyone can define quests and ambiance in plain text.
🛠 Open mod toolkit — to let the community fold in new assets, specs, and encounters.

Kiro didn’t just save me time — it changed how I think about making games. Boilerplate is gone. Specs are the source of truth. And AI pair‑programming feels less like automation, more like co‑creation.

Let’s keep bending the rules of development — one spec at a time. #kiro

If you’d like, I can now weave in direct links to your YAML, hooks, and ProceduralMapGenerator code snippets so Devpost judges can see the magic, not just read about it — that extra transparency often earns bonus points in hackathons. Would you like me to prepare that version?