InnerOS-Sovereign Multi-Agent Swarm for IT Field Operations

Eight agents run a real IT ops flow: voice in, MongoDB quote out, WhatsApp alert. Google AI Studio design. Local CrewAI + Gemini + MongoDB MCP.

Comment

💡 Inspiration As founders running a real IT services company in Ecuador (PC Doctor), we hit the same wall every SMB faces: field technicians dictate findings on WhatsApp, sales chases quotes in email, finance needs SRI tax validation and 15% VAT—and nothing talks to anything else. Fragmented SaaS tools mean data silos, monthly fees, and zero control over sensitive client data.

InnerOS started from a simple question: What if one coordinated swarm of specialized agents could run the whole operational loop—from field voice to MongoDB quote to client alert—on infrastructure we own?

We explored multi-agent design with Antigravity, prototyped the eight-agent “Droid” experience in Google AI Studio, and shipped the production system as a sovereign local stack because our business needs real tools (SRI, IMAP, WhatsApp), not a chatbot demo.

⚙️ What it does InnerOS is a self-hosted multi-agent orchestrator for technical field operations. Users interact through Ralphi IA v2.0—a control center with a live swarm view (/inneros), conversational data center, email monitor, visits, quotes, and reports.

When a technician speaks or types a request (e.g., “Quote a 16-port PoE switch for Torres de la Merced”), the swarm runs a multi-step mission:

D1 Mail Gatekeeper — monitors IMAP for urgent quote requests D2 Field Voice — transcribes audio with Whisper and structures findings D3 Cosmos — orchestrates the workflow in MongoDB (pcdoctor_swarm) D4 Care-Taker — generates technical reports and exports D5 Financial — validates Ecuador RUC/SRI and builds quotes with IVA D6 Catalyst RAG — technical knowledge and web-assisted answers D7 Signer — XAdES e-invoicing (roadmap) D8 Comms — WhatsApp alerts via Evolution API One Start Demo button runs the full pipeline: inspection → report → quote → notification. This is not Q&A—it is task execution with tools.

🛠️ How we built it InnerOS uses a hybrid architecture: designed in Google’s agent ecosystem, executed on sovereign local hardware.

  1. Design layer — Google AI Studio (Agent Builder) We prototyped the eight-agent UX, Gemini integration, and mission narrative in Google AI Studio before production implementation.

  2. Orchestration layer — CrewAI (local) FastAPI (:8100) runs CrewAI agents with real Python tools: MongoDB CRUD, SRI/RUC lookup, PDF/report export, IMAP polling, and WhatsApp. Ollama handles local inference; when tool-calling is unavailable, a deterministic demo path keeps the hackathon flow reliable.

  3. Reasoning layer — Gemini (Google Cloud) Gemini API powers classification and assistant reasoning. Critical business steps (quotes, reports, database writes) run through verifiable local tools—Gemini plans and interprets; the swarm executes.

  4. Partner layer — MongoDB MCP We integrated the MongoDB MCP server (hackathon partner) so agents can query operational collections with traceability—clients, visits, inventory, quotes—without exposing raw credentials to public APIs.

  5. UI layer — React admin Ralphi IA v2.0 (:5173) provides bilingual (EN/ES) operations UI, swarm visualization with live agent status, and quick access to every module.

🚧 Challenges we ran into From prototype to production. Google AI Studio gave us a compelling UI, but simulations and browser storage were not enough for a real demo. We rebuilt execution on CrewAI + FastAPI while keeping the eight-agent story.

Tool-calling and local LLMs. Not every Ollama model supports agent tools. We added a robust fallback so the tour demo always completes—inspection and quote land in MongoDB even when the full CrewAI chain cannot run.

State and idempotency. Multi-step flows hit DuplicateKeyError when the same inspection was created twice. We fixed orchestration so each mission has a single source of truth in MongoDB.

Real integrations are messy. SRI validation, IMAP, Evolution WhatsApp, and Whisper each have their own failure modes. We learned to show partial success honestly (e.g., quote saved even if WhatsApp is offline).

Hackathon vs. sovereignty. The challenge asks for Gemini and Agent Builder; our business asks for local control. The answer was hybrid: Google for design and reasoning, local for execution and data.

🏆 Accomplishments that we're proud of A real multi-agent mission, not a chat wrapper: voice/text → MongoDB → report → quote → WhatsApp attempt in one orchestrated flow Eight specialized agents with live status UI, click-to-explain roles, and SVG swarm visualization MongoDB partner integration with real collections and MCP configuration for agent-assisted queries Google AI Studio prototype linked to a working production admin on sovereign infrastructure Bilingual UI (EN/ES) for presenting to international judges while serving our Ecuador operations Honest architecture we can demo, defend, and extend after the hackathon 🧠 What we learned LLMs are reasoning engines, not the whole system. The winning pattern for SMBs is: Gemini (or cloud) for planning and interpretation; local agents + tools for execution and auditability.

RAG alone is not enough for operations—you need structured workflows, persistent state in MongoDB, and handoffs between specialized agents.

MCP matters. Partner MCP servers let you connect frontier models to live data without rebuilding every integration as a custom API.

Prototyping in Google AI Studio accelerated our UX and narrative; shipping locally is what made InnerOS real for PC Doctor.

🔮 What's next for InnerOS Near term (post-hackathon):

Expose Gemini mission planning as a visible step before CrewAI execution Surface MongoDB MCP queries inside the demo UI (not only in Cursor) Connect D7 Signer to Ecuador XAdES e-invoicing Optional Cloud Run “Director” microservice for Gemini planning while keeping tools local Long term: Open-source blueprint for technical SMBs that want agent orchestration without surrendering data sovereignty—Gemini for intelligence, MCP for connectivity, local stack for trust.

Built With

Share this project:

Updates