NexusMind AI

An autonomous AI agent that plans, executes, self-corrects, and learns — turning one sentence into a complete workflow.

Comment

Description

Most AI today waits for you to ask. NexusMind AI doesn't.

It's an autonomous task-execution agent that receives goals — via API, webhooks, or a live dashboard — and handles multi-step workflows end-to-end without hand-holding. Describe what you want in plain English, and the agent works one action at a time: it plans a path, executes a tool, reads the real result (including errors) before deciding the next move, self-corrects, asks permission for anything risky, and learns from every task it finishes. Watch the whole thing happen live in the dashboard.

30-second version for judges: give it a goal and it plans, executes, self-corrects, and verifies its own work before declaring done. Give it a standing instruction and it enforces that instruction automatically every time a matching event fires — 24/7, across 11 platforms, without you in the loop. All of it built on the hackathon's mandatory stack: Gemini 3.5 Flash, Google ADK, Cloud Run, Firestore, and Pub/Sub.

The Problem

Developers lose real hours every day to low-judgment, high-volume attention work that doesn't need a human mind, just human eyes: reviewing PRs, scanning Slack for mentions, checking Jira blockers, monitoring Reddit/Hacker News, triaging email. Individually each task is small. Across a day it adds up to roughly 2–2.5 hours of pure context-switching — for a 10-person team, 20+ hours a week that isn't spent building anything.

Traditional AI assistants help with one step at a time but stall the moment something fails and need a human to redirect them. NexusMind is built to run the whole loop: watch the platforms, decide what needs attention, act on it, and only escalate to a human when judgment genuinely matters.

How It Works

  1. Plan — Gemini 3.5 Flash produces a best-effort roadmap: ordered steps, dependencies resolved, each step mapped to a tool.
  2. Execute, one step at a time — the agent decides a single action, runs it, and reads the actual result before deciding the next one. This is an adaptive loop, not a one-shot script, so it survives the kind of partial failures real workflows produce.
  3. Self-correct — a failed step (bad parameters, a timeout, an unexpected result) feeds straight into the next decision: fix the call, switch tools, or verify state before continuing.
  4. Verify and finish — before declaring a goal done, the agent checks that the artifacts it claims to have produced actually exist.
  5. Approve — high-risk actions (running code, shell commands, sending messages, merging things) pause for one-click human approval, on the dashboard or through Telegram.
  6. Learn — after each task, the agent reflects on the outcome and saves what it learned to persistent memory, recalled on future tasks.
  7. Trace — every decision, tool call, and approval streams to the live dashboard as it happens, so nothing runs invisibly.

Key Capabilities

NexusMind ships with 25 implemented, tested capabilities. A few that matter most :

  • Adaptive step-by-step execution — one decision, one execution, one real result, repeat. The agent self-corrects and verifies its own output rather than trusting a static plan.
  • Complexity-aware routing — trivial requests get a single fast Gemini call; single-tool requests execute directly; only genuinely complex, multi-step builds trigger the full planning loop. Normal tasks run in a fraction of a second instead of paying planning overhead every time.
  • Elastic execution budget with failure guards — the step budget extends automatically while the agent is making real progress, with a hard ceiling and an abort after repeated consecutive failures, so it neither gives up too early nor runs away.
  • Live streaming everywhere — token-by-token model output and tool output stream to the dashboard over WebSocket/SSE in real time, alongside a live checklist the agent updates as it works.
  • Persistent hybrid memory — full-text and vector-style retrieval with trust scoring, so the agent gets better calibrated about what to trust over time rather than treating every memory equally.
  • Self-evolving skills — solved multi-step tasks are distilled into reusable SKILL.md procedures, with usage tracking, a lifecycle (active → stale → archived), and a signed audit ledger.
  • Human-in-the-loop approval — a smart approval gate decides what actually needs a human (three modes: smart / always / never), with one-click approval from a phone via Telegram.
  • 11 event-driven watchers with write-back — GitHub, GitLab, Slack, Discord, Jira, Reddit, Hacker News, Email, RSS/Atom, Cron, and custom Webhooks. Most can act, not just detect: merge a PR, reply in a thread, comment on an issue, send an email.
  • Memory-gated autonomy — a watcher only takes action when a matching standing instruction actually exists in memory. No match, no silent action — it flags the gap and asks instead of guessing.
  • 285 passing tests across models, memory, skills, routing, the execution loop, the executor, the API, and all 11 watchers.

Tools — 30 tools across 9 skill packs

Category Tools Risk
Core (12) web search, URL fetch, file read/write, directory listing, JSON parsing, summarization, structured extraction, code execution, shell commands, checklist management, subagent delegation Mixed — reading/analysis is autonomous; code execution and shell commands require approval
GitHub (9) Resolve/fetch repos, list/get/review/merge/close PRs, local verification, batch decision application Reads are safe; merge/close require approval
Slack, Discord, Jira, GitLab, Email (9 total) Send messages, reply in threads, comment on issues, transition issue status, list/get/merge merge requests, send email Reads are safe; every write action requires approval

Architecture

Dashboard → FastAPI → Pub/Sub → Orchestrator → Gemini + Tools → Firestore / Cloud Run

Event-driven rather than polling-based: webhooks and monitored platforms push events into Pub/Sub, which triggers the orchestrator to plan, execute, gate approvals, update memory, and stream traces live. That makes NexusMind a workflow engine, not a chatbot with a nicer interface.

Track

The Taskmaster — event-driven workflow with autonomous routing.

Tech Stack

Layer Technology
LLM Gemini 3.5 Flash, multi-key rotation
Agent Framework Google ADK 2.x
Cloud Deployment Google Cloud Run (scales to zero)
Persistent State Firestore
Event Routing Cloud Pub/Sub
API FastAPI + Uvicorn
Language Python 3.11+
Testing pytest + pytest-asyncio, 285 tests
Tools 30 across 9 skill packs
Watchers 11 platforms/sources, all write-back capable

How We Built It

NexusMind adapts behavioral patterns from three open-source agent projects, reimplemented in Python/FastAPI/Gemini rather than copied — full source-level mapping is in ATTRIBUTIONS.md.

  • From OpenClaw: multi-step task decomposition, a tool registry with sandboxed execution, plan recovery when a step fails.
  • From Hermes Agent: persistent cross-session memory with hybrid retrieval and trust scoring, self-evolving skills, post-task reflection, a zero-cost deterministic command gate, and a repair ladder for hallucinated tool names.
  • From opencode: the adaptive one-decision-at-a-time execution loop, token/tool-output streaming over a global event bus, and the checklist/subagent delegation tools.

What we added on top: event-driven Pub/Sub routing, a complexity-aware router so trivial requests skip full planning, smart human-approval gating with Telegram, live full-stack traceability, multi-key Gemini rotation with backoff, and memory-gated watcher autonomy so the agent never acts on a platform without an explicit standing instruction to do so.

This isn't an LLM wrapper — it's a complete autonomous task-execution system built around the model, with its own routing, memory, and safety layers.

Cloud Integration

  • Cloud Run — serverless deployment, scales to zero when idle.
  • Firestore — crash-recoverable task state and persistent memory.
  • Cloud Pub/Sub — event-driven task routing from external webhooks.
  • Google ADK — agent framework integration with memory-prefetch, approval-gate, and reflection callbacks built into the run loop.

Dashboard

Real-time reasoning chain, a live checklist with priority badges, color-coded trace spans (tool calls, reasoning, approvals, errors), the human-approval interface, a memory browser, and the full tool/watcher registry — all streaming live rather than refreshing on a timer.

Built as a Solo Project

I built NexusMind alone: architecture, implementation, integration, debugging, testing, deployment, documentation, and demo prep. I used an AI assistant as a development partner throughout — for coding help, debugging, researching approaches, exploring architecture decisions, refactoring, and troubleshooting deployment. The final system, technical decisions, and submission were mine. This project ended up being as much an experiment in AI-assisted engineering as it was in agentic AI.

Challenges We Ran Into

  1. Gemini API rate limits — solved with multi-key rotation and automatic backoff.
  2. Template resolution — planner output references results from earlier steps that only exist at runtime; resolving those correctly took real iteration.
  3. One-shot planning truncation — ambitious goals (build a whole site in one step) blew past the model's output-token cap and silently truncated. Fixed by forcing smaller per-file steps, raising the planning token budget, and moving to the step-by-step execution loop so the agent no longer depends on a perfect plan up front.
  4. Non-blocking task execution — background execution with live event polling so the dashboard stays responsive during long-running tasks.
  5. GCP credits without a credit card — Google Cloud credits required a credit card I didn't have. I built a Cloud Shell setup script that configures and deploys the whole project without the original workflow I'd planned — which ended up making the project easier for others to reproduce, too.
  6. A 4-minute limit on a system that needed 25 — the first cut of the demo ran 25 minutes. Fitting the 4-minute submission cap meant cutting hard and compressing the workflow. The final video shows the core loop — goal → plan → execution → live trace → risky action → human approval → completion → reflection — but doesn't capture everything: persistent memory, self-evolving skills, all 11 watchers, and the full API surface are in the repo even where they didn't make the cut.

Accomplishments We're Proud Of

  1. Working step-by-step self-correction — the agent watches each action's real result and fixes failures before the next move, instead of trusting a static plan.
  2. Live dashboard — real-time visibility into agent reasoning, with every step appearing as it runs.
  3. 11 watchers, all write-back capable — not just detection; the agent can merge, reply, comment, and send across platforms once memory confirms it has permission to.
  4. Clean, modular architecture — skills, memory, execution, and observability live in separate, testable components.
  5. 285 passing tests — covering models, memory, skill lifecycle, routing, the adaptive execution loop, the executor, the orchestrator, and the API.
  6. Production-minded code — error handling, logging, type hints, and documentation throughout, not just demo-ware.

What We Learned

  1. Event-driven beats polling — Pub/Sub is more efficient and scales better than an agent that checks in on a timer.
  2. Self-correction matters more than a perfect first plan — real workflows fail; the ability to recover is worth more than getting it right on the first try.
  3. Memory is what makes an agent worth using long-term — without it, every task starts from zero and nothing improves.
  4. Human approval builds trust, not friction — a well-placed approval gate lets people hand over real autonomy without feeling like they've lost control.
  5. Google Cloud's scale-to-zero model is genuinely cost-effective for a project like this, run intermittently rather than constantly.

What's Next

  1. Google Calendar integration — schedule and manage events autonomously.
  2. Deeper Jira/Linear integration — bi-directional issue tracking workflows.
  3. Multi-agent delegation — parallel task execution across specialized sub-agents.
  4. Voice interface — speak goals instead of typing them.
  5. Production-grade semantic retrieval — Vertex Vector Search in place of the current hybrid retrieval approach.
  6. A cost dashboard — track Gemini API usage and spend per task.

Open-Source Acknowledgments

NexusMind incorporates selected agent patterns inspired by OpenClaw, Hermes Agent, and opencode. These patterns were reimplemented in Python/FastAPI/Gemini and integrated into NexusMind's own architecture — no source code was copied. Full attribution and source-file mapping: docs/ATTRIBUTIONS.md.

Built With

Share this project:

Updates

Submission history