My 5-Day AI Agents Intensive Journey — And How I Built a Google-Native MindsEye OS Using 6 Repos

Intro — A Course That Changed How I See Agentic Systems

When I started the 5-Day AI Agents Intensive with Google & Kaggle, I expected another technical bootcamp.

I was wrong.

The course wasn’t just “how to build an agent.”
It reframed what an agent is —
not a single script, not a chatbot, not a workflow…

…but a living architectural pattern:

perceiving

reasoning

deciding

acting

reflecting

and adapting over time.

By Day 5, something clicked for me:

“If agents fundamentally revolve around perception → memory → reasoning → action → feedback… then the tool we choose doesn’t matter as much as the architecture we build around it.”

That insight pushed me to design something more ambitious than just a capstone.

I built an entire agentic operating system using nothing but:

Google Workspace

Gemini (conceptually, until I can access paid API)

Apps Script

Node.js

and six GitHub repos working together.

This became my capstone —
and honestly one of my favorite projects I’ve ever built.

1. What Resonated Most: Agents Are Not Single Agents — They Are SYSTEMS

Throughout the course, Google hammered several core topics:

1 — Event-driven architecture

Agents shouldn't always “run.”
They should wake up when something meaningful happens.

2 — Memory as a first-class citizen

An agent without memory is a toy.
An agent with structured memory becomes a system.

3 — Tools as capabilities, not dependencies

Agents should be able to pick the right tool at the right time.

4 — Multi-agent ecosystems

The real power is not a single agent,
but multiple components interacting over shared state.

And THAT was the turning point for me.

Because I realized:

Google Workspace is already a multi-agent ecosystem.

Gmail = event stream
Docs = long-form memory
Sheets = structured memory
Forms = intake interface
Apps Script = automation spine
Gemini = reasoning engine

So instead of building one agent…

…I built a Google-native agentic OS.

1. My Capstone Project — MindsEye OS Across 6 Repos

Here is the full architecture (all repos are public):

1. Workspace Automation Layer

🔗 https://github.com/PEACEBINFLOW/mindseye-workspace-automation

Captures events from Gmail, Docs, Drive, Forms → normalizes → sends to ledger.

1. The Ledger (Prompt Evolution Tree + Runs)

🔗 https://github.com/PEACEBINFLOW/mindseye-google-ledger

A time-labeled memory system (soft blockchain).
Nodes = prompts / ideas.
Runs = executions / results.

1. Gemini Orchestrator (Kernel)

🔗 https://github.com/PEACEBINFLOW/mindseye-gemini-orchestrator

This is where Gemini will live as the reasoning engine.

1. Devlog Generator

🔗 https://github.com/PEACEBINFLOW/mindseye-google-devlog

Turns the ledger into weekly narrative summaries.

1. Analytics Engine

🔗 https://github.com/PEACEBINFLOW/mindseye-google-analytics

Exports → Looker dashboards → KPI insights.

1. Workflow Atlas (Portal Maps)

🔗 https://github.com/PEACEBINFLOW/mindseye-google-workflows

Everything described as YAML “portal flows” so the whole OS can be understood.

1. How My Understanding of Agents Evolved Before the course:

“Agents are programs that take an input and produce a dynamic output.”

After the course:

“Agents are architectures built around structured memory, perception streams, execution graphs, and feedback loops.”

This shift shaped my design:

1. Mapping Course Concepts → My MindsEye OS

Here’s how each idea in the course shaped each repo.

4.1 Perception: Workspace Automation Repo

Course Concept:
Agents start with perception channels — email triggers, file events, user actions.

My Implementation:
I built an event listener layer using Apps Script:

Gmail label “Send to MindsEye”

Docs custom menu

Drive folder watchers

Form submissions

Every event becomes:

{
"surface": "gmail",
"event_type": "label_applied",
"title": "...",
"source_url": "...",
"summary": "...",
"timestamp": "..."
}

This normalized event is the perception signal.

4.2 Memory: The Ledger Repo

Course Concept:
Agents evolve when their memory evolves.
Memory = core.

My Implementation:
A Google Sheet (nodes + runs) functioning as a soft blockchain:

Nodes = ideas, prompts, branches

Runs = experiments, AI outputs, score, context

Everything is append-only + time-labeled.

The result:

A living, multi-user, multi-team evolutionary tree of intelligence.

4.3 Reasoning: The Gemini Orchestrator Repo

Course Concept:
Reasoning = choosing a strategy from memory + context.

My Implementation:
mindseye-gemini-orchestrator is a Node.js kernel:

Selects nodes ready to run

Passes metadata + linked Docs into Gemini

Logs run results back as new memories

Once I have Gemini credits, it becomes an actual functioning kernel.

4.4 Reflection: Devlog Repo

Course Concept:
Agents should reflect, explain, summarize.

My Implementation:
The Devlog generator groups runs, detects patterns, and writes weekly summaries.

It turns raw memory into narrative memory.

4.5 Insight: Analytics Repo

Course Concept:
Agents need feedback loops.

My Implementation:
Exports → Python scripts → Looker dashboards:

run frequency

success rates

node lineage

surface usage

prompt performance

This becomes the intelligence lens across 200+ users.

4.6 Orchestration: Workflows Repo

Course Concept:
Multi-agent systems require explicit coordination, NOT magic.

My Implementation:
I built YAML “portal maps” describing flows like:

trigger: workspace_event
steps:

• normalize_event
• write_to_nodes
• schedule_gemini_run
• generate_devlog
• refresh_analytics

This repo is the architecture documentation for MindsEye OS.

1. What I Learned (In One Sentence)

The future of AI isn’t one agent — it’s an ecosystem of interconnected subsystems that perceive, remember, reason, act, and reflect in coordinated loops.

This course gave me the mental model.
My six repos gave me the playground.

1. Why This Matters (Especially for Teams of 200)

I designed the system so:

200 people can create their own prompt trees

their data never overwrites each other

all nodes and runs become shared, structured memory

patterns flow between teams even when raw data is siloed

Gemini becomes the reasoning core for the whole organization

It becomes a Google-native AI operating system.

Lightweight.
Auditable.
Extensible.
Future-proof.
And once Gemini API access becomes available — fully agentic.

1. Final Reflection — “I Didn’t Build an Agent. I Built an OS.”

The course didn’t just teach me how to build agents.

It taught me how to think like a system designer.

It pushed me to:

move from 1 agent → multi-agent

move from scripts → architecture

move from outputs → memory

move from tools → capabilities

move from workflows → operating systems

This became my capstone.

Six repos.
One architecture.
A Google-native MindsEye OS.
Built with no cloud budget, no paid credits — just design and pattern recognition.

And I’m only getting started.