Robin: A self-evolving orchestration sidekick for CEOs

• 

  Robin makes the most of your whole stack and gets better and better everyday.

Inspiration

Every CEO we know runs their company out of meetings and messages: strategy arrives as a rambling voice note, a Meet that ended five minutes ago, or a "can someone own this?" email. The work that follows is brutally mechanical - pull the context, split the goal into real workstreams, do the parts a machine can verifiably do, and hand people only the parts that genuinely need human judgment. Today that translation layer is the CEO's evening.

We wanted the opposite: a sidekick that takes the messy high-level message, mobilizes into finished, verified work inside the company's own Google Workspace, and - this is the part that hooked us - gets measurably better the second time, because it keeps durable structured memory of your doctrine, your people, and its own postmortems. Not a chat wrapper over history: an evolving-knowledge system that actively mutates its own operating state.

What it does

Robin is a collaborative execution orchestrator for executives, delivered as one remote MCP service inside a Gemini Connected App - no separate frontend. You give Robin a high-level goal directly or through a completed Google Meet, and it:

• enriches the goal from your authorized Drive context (multimodal retrieval over docs, PDFs, images, audio, video via Gemini Embedding 2);
• compiles a recursive goal hierarchy - internal goals compose subgoals, leaf subgoals own executable workflows, and cross-branch dependencies cascade into verification gates;
• performs the maximal safe agentic work with parser-gated verification at every seam, then publishes finished results to their authoritative Workspace destinations with provider read-back;
• packages only the irreducibly human remainder as contextualized Drive handoff packages and concise Gmail assignments;
• runs a sealed postmortem after every terminal run that can promote operational memory, fixed specialists, and even application-authored custom utilities - evaluated in a Bubblewrap sandbox and independently reviewed before any future run may load them.

Each organization gets a fully isolated tenant: its own Google Cloud project, VM, storage, credential custody, and billing. Every Gemini, embedding, and media-model call is charged to the customer's project - there is no shared execution pool to leak context or cost through.

How we built it

All-Google, deliberately: Gemini 3.7 Flash through Vertex AI with the Antigravity SDK is the load-bearing engine for perception, compilation, execution, review, and projection; Gemini Embedding 2 powers hybrid semantic/keyword/multimodal retrieval (SQLite + FTS5 + sqlite-vec); assignment-scoped worker tools pin Gemma 4 (independent review), Veo 3.1 (video), Lyria 3 (music), and Nano Banana 2 (image) to the tenant's own quota. The platform is Google Cloud end to end: Compute Engine gateway and per-tenant VMs, Persistent Disk, Secret Manager credential vault, Cloud Storage for signed immutable releases, Pub/Sub + Workspace Events for Meet ingress, IAM, monitoring, and budgets.

The runtime is Bun. Every agent seam is schema-gated; every provider mutation must survive read-back; every release is content-addressed, Ed25519-signed, and health-gated with automatic rollback. We built deterministic fakes for every provider boundary so the whole product - goal compilation, tenant provisioning, OAuth, Workspace publication, evolution governance - is exercised by 887 standalone tests that run with zero model spend and zero network, straight from a fresh clone.

Challenges we ran into

The honest list is long, and the best ones came from using our own product on deadline day:

• Returning users are where fail-closed designs go to fight you. Our credential vault, authorization authority, custody transfer, and installation journey each bound identity evidence exactly once, on purpose. The first re-authorization by the same CEO hit four separate "cannot replace" walls. We shipped four signed production releases in one afternoon, converting each barrier into identity-pinned rotation - same Google subject, same pinned redirect - without loosening a single foreign-identity rejection.
• Chrome enforces CSP form-action on redirect targets, so our own security header blocked our OAuth handoff to Google. One-line fix, humbling lesson.
• Judging safety versus autonomy: act-first execution needed hard boundaries - per-session submission budgets, catalog-bound capability grants, one-attempt paid-model ledgers with a $0.61 ceiling, and communication outcomes that can never be laundered into document completion.
• Deadline truth-telling: our live customer-tenant acceptance transaction didn't complete before the freeze (the tenant VM bootstrap still fails, honestly recorded). We chose to state that boundary plainly rather than fake it - the repository discloses exactly what is live-proven and what is deterministically tested.

Accomplishments that we're proud of

• A real evolving-knowledge loop: taught rules and postmortem promotions provably change the next run - including a hash-sealed control/treatment causal-proof harness that demonstrates memory changed the outcome.
• Governed self-evolution: Robin can author its own new deterministic utilities, which must pass sandboxed evaluation and independent review before activation - self-improvement with receipts.
• 887 deterministic tests from a clean clone, no keys, no corpus, no network - the whole product contract is reproducible for free.
• A live, signed, restart-proven public gateway at robin.apptory.ai with immutable release lineage and automatic rollback.
• Radical tenant isolation with customer-owned billing - the architecture a real company could actually adopt.

What we learned

Fail-closed systems don't fail loudly in development; they fail the first time a real user does something twice. Dogfooding the product through its own Gemini Connected App surfaced more truth in three hours than a week of local hardening. Deterministic provider fakes are the highest-leverage investment an agentic product can make - they let us adversarially test autonomy, isolation, and recovery thousands of times at zero cost. And building an agent with agents taught us that verification gates, not vibes, are what let you move fast: every seam that could lie eventually tried to.

What's next for Robin: A self-evolving orchestration sidekick for CEOs

Finish the one live customer-tenant acceptance transaction our freeze deadline deferred - the full packet from Meet ingress to customer-billed Veo/Lyria/Gemma receipts. Complete Google OAuth app verification so installation is warning-free. Then widen the human edge: multi-employee delivery adapters, richer steering during in-flight runs, and deeper self-evolution - letting Robin's postmortems propose not just utilities and rules, but improvements to its own workflows, always behind the same sealed evaluation gates.

Built With

• bun
• gcp
• gemini