NEXORA — the autonomous goal compiler

Give it one sentence. A workforce of Gemini 3.5 agents on Google ADK writes a contract for "done", plans the work, builds every deliverable, verifies each one, then files it all in one Drive folder.

Comment

One sentence in. A verified workspace out.

NEXORA turns a single instruction — "Plan our Lisbon offsite, March 3–5, for six people: an agenda doc and a shared budget in USD, and hold 11am tomorrow for the kickoff call with a Meet link" — into a Google Drive folder of finished, formatted work: a written agenda, a currency-formatted budget sheet, a generated hero image, and a real calendar hold with a Meet link. Every deliverable is checked against a contract that NEXORA wrote itself, before you ever see it.

What inspired it

Knowledge work is full of tasks that are individually trivial and collectively exhausting: research the thing, write it up, build the spreadsheet, make the deck, draft the email, book the meeting, file it somewhere sensible — then check that nothing was missed. Every step is a context switch, and the "check nothing was missed" step almost never happens.

A chatbot answers a question. It doesn't do the task, and it definitely doesn't check its own work. We wanted an agent that behaves like a competent operator you delegate to: it figures out what "done" means, does the whole job, verifies it, fixes its own gaps, and hands back real artifacts — not a wall of text.

How we built it

NEXORA is a pipeline of Gemini 3.5 agents, each running as a Google ADK LlmAgent through an ADK Runner, with Vertex AI Agent Engine providing managed Sessions and a Memory Bank:

  1. Understand — Gemini restates the goal as a structured intent.
  2. Contract — Gemini writes an Outcome Contract: the checkable definition of "done" (concrete deliverables, the evidence each needs, constraints). This is the heart of the Taskmaster claim — NEXORA is not a generator, it's a contract.
  3. Discover — it scans the connected workspace so it doesn't rebuild what already exists.
  4. Plan — the Mission Architect agent compiles the goal + contract into a dependency graph of capabilities (never raw API calls), research-before-synthesis. A Plan Critic agent can reject the whole plan.
  5. Execute — a workforce of six specialist agents (Research Analyst, Writer, Financial Analyst, Designer, Coordinator, Visual Designer) runs the graph in parallel. Gemini writes the actual document body, slide copy and costed spreadsheet rows from the gathered evidence; formatting.py renders them into real Google Docs/Sheets/Slides/Gmail with heading styles, bold runs, bullet lists, a frozen currency-formatted budget, a themed deck, a branded HTML email.
  6. Verify — the QA Auditor agent reads the produced artifacts and rules each contract deliverable SATISFIED / PARTIAL / MISSING. A mission is COMPLETED only when every deliverable is SATISFIED; otherwise it is honestly PARTIAL_SUCCESS with per-deliverable reasons.
  7. Repair — a gap feeds the Adaptive Replanner, which proposes a small follow-up plan (max 3 nodes), re-critiques it and re-executes — bounded to 2 cycles so a stubborn deliverable can't burn the budget. A mission is complete only when the contract is fully satisfied: $$\text{done} \iff \forall\, d \in \text{Contract}:\ \text{verdict}(d) = \texttt{SATISFIED}$$ Otherwise the Adaptive Replanner runs, bounded to ( k \le 2 ) cycles of at most 3 nodes each.
  8. Deliver — every artifact is filed into one Mission Workspace Drive folder.

Multimodality is in the pipeline, not bolted on: voice input, screenshot analysis via Gemini Vision, generated concept images (gemini-2.5-flash-image), a cinematic clip (Veo 3.1 Fast), original instrumental music (Lyria 2), and spoken briefings (Gemini 2.5 Flash TTS). A second-opinion prompt-injection classifier runs on Gemma 4.

It runs over time. A goal can be scheduled (once / daily / weekdays / weekly / monthly). The mission for next Monday doesn't exist until Monday — Cloud Scheduler fires due goals every minute; schedules persist in Firestore and survive a restart.

The same code runs on a laptop and on Cloud Run — environment variables decide what's real. The entire pipeline (contract → plan → execute → verify → repair) runs end-to-end with zero API spend on EXECUTION_MODE=MOCK and only a Gemini key. That's how it was built, and how a judge can run it now.

Stack: FastAPI · Google ADK · Google GenAI SDK · Vertex AI Agent Engine · Gemini 3.5 · Firestore · Cloud Tasks · Cloud Scheduler · Cloud Run · Secret Manager · Next.js. 154 hermetic tests. One-command deploy.sh + Terraform.

What we learned

  • "Done" is a spec problem, not a prompt problem. The single biggest quality jump came from making the model write a contract first and then grading artifacts against it — not from a better execution prompt.
  • Verification has to be a gate, not a report. Once the Auditor's verdict could trigger a bounded replan, "the model got a deliverable wrong" stopped being a demo-killer.
  • Untrusted text must be quarantined before a model sees it. Every email/Drive/web string is scanned for injection signatures before it reaches a prompt; the demo inbox contains a malicious message and you can watch it get dropped.
  • Provider seams keep you honest. Every external dependency (LLM, workspace, research, memory, state, dispatch, media) sits behind an interface chosen by one env var, so the offline demo is as substantive as the real one.

Challenges we ran into

  • Vertex "express mode" hijack. The GenAI SDK reads both GEMINI_API_KEY and GOOGLE_API_KEY; with GOOGLE_GENAI_USE_VERTEXAI=true and a visible key it silently routed calls to the key's project instead of ours. Fix: stash the key under a private name and strip both public names on the Vertex path.
  • New-project IAM. Cloud Build 403s (storage.objects.get) and Cloud Tasks iam.serviceAccounts.actAs 403s because new GCP projects no longer grant the Compute default SA the roles builds need. deploy.sh now grants them explicitly, enables each API one at a time with retries for the transient service-agent errors, and self-binds actAs.
  • Media auth scope. Veo/Lyria need a cloud-platform token, which the Workspace OAuth token doesn't carry — they use Application Default Credentials (the Cloud Run service account in prod), separate from the user's Workspace grant.
  • Cross-instance state. In-memory missions 404'd when Cloud Run scaled out; the demo deploy profile now pins to exactly one always-warm instance, and the scale profile moves state to Firestore + Cloud Tasks.
  • Lyria is prompt-picky. It rejects some prompts outright; NEXORA retries once with a plain instrumental prompt, then falls back gracefully.
  • The QA Auditor was too literal. It marked LIVE deliverables PARTIAL when it couldn't re-open the file, and over an off-by-one slide count. It now judges the produced content it's handed, and substance over arithmetic.

Try it

  • Live Command Center — https://nexora-mini.vercel.app (Vercel) → Cloud Run service nexora-api → Vertex AI (Gemini 3.5 + Agent Engine). No login; pick a scenario and hit Launch.
  • Proof it's live: curl https://nexora-api-z4oqiagpgq-uc.a.run.app/api/v1/config returns the running stack — project nexora-506905, Agent Engine id, models, Google ADK.
  • Code (reproducible, runs offline): https://github.com/TusharTechs/nexora — EXECUTION_MODE=MOCK + a Gemini key runs the whole pipeline with no Google account and no spend.

Built With

Share this project:

Updates