NeuroWorks

NeuroWorks: Secure, local-first AI digital workers that turn job descriptions into operational capacity with human-in-the-loop governance.

Comment

The Story of NeuroWorks

What Inspired Us

The core inspiration for NeuroWorks stems from a structural capacity crisis within institutions across Zimbabwe and the broader region. Organizations—ranging from public sector departments like PRAZ and MOHCC to local NGOs and financial desks—are routinely overwhelmed by the sheer volume of compliance, reporting, and operational coordination required of them. We observed that a single program officer is often forced to act as multiple specialists simultaneously, leading to missed deadlines and slipping quality.

Traditional software configuration feels like an industrial-era relic that fails to bridge this gap. We wanted to build something fundamentally different: a system where an institution can brief a digital worker exactly like a human new hire, managing them through plain-language policies rather than rigid code.

How We Built It

NeuroWorks was built from the ground up using a secure, local-first, three-layer architecture designed to protect institutional data sovereignty:

  • Layer 1 (Infrastructure): The foundation relies on a robust open-source stack featuring Node.js/Express, Next.js 14, PostgreSQL for relational data, Redis for working memory queues, and Qdrant for secure vector isolation. Local model inference is powered via Ollama.

  • Layer 2 (HERMES Governance Layer): To ensure safety, we built HERMES, an Model Context Protocol (MCP) tool-governance layer comprising roughly 90 allowlisted primitives across 12 namespaces. This restricts exactly what actions an agent can perform.

  • Layer 3 (Orchestration): Digital workers are orchestrated via LangGraph multi-agent workflows. These agents plan their execution path, call permitted tools via HERMES, and halt at a mandatory Human-in-the-Loop (HITL) gate for authorization before executing any consequential action.

The default system configuration runs inference entirely on operator-owned GPU workstations or servers (such as a consumer-grade RTX 3060). This ensures that sensitive data never leaves the local machine unless an operator explicitly opts into cloud escalation (e.g., Anthropic's Claude API via OpenRouter).

The Challenges We Faced

Building a production-ready multi-agent platform for real-world enterprise environments brought significant hurdles:

  1. Balancing Local Compute vs. Performance: Running models locally meant optimizing within strict hardware limits. We achieved a baseline where $62.7\%$ of all inference calls are served completely locally using quantized configurations of Qwen 2.5 (7B) and Llama 3.2 (3B), keeping operating costs down to a fraction of cloud-only alternatives.

  2. Strict Pre-Execution Governance: Preventing agent hallucinations or unauthorized actions in financial or medical frameworks required intense testing. We implemented a multi-layered validation guardrail featuring automated quality.check scoring, peer-review model passes, and automated data-gap injections. We tested this heavily by planting policy violations to ensure the HITL gate successfully catches and flags them before execution.

  3. Security and Development Slip-ups: Security is an ongoing battle. Early in development, we hit a real-world hurdle when a GitHub Personal Access Token (PAT) was inadvertently exposed in a terminal log. We caught it immediately, revoked the credential, and structured strict origin-guard middleware and isolated sandboxes (using E2B) to protect dynamically generated code execution from affecting production environments.

What We Learned

Through building NeuroWorks, we learned that artificial intelligence should not be a "sledgehammer" applied blindly to every problem. Many deterministic tasks, such as routine database lookups or organization filtering, are highly inefficient when routed through a Large Language Model. By explicitly implementing deterministic operations as plain function calls and preserving the LLM only for unstructured context synthesis and multi-step planning, we built a leaner, significantly more reliable platform.

Furthermore, we realized that non-technical users do not want to become "prompt engineers." The success of an AI platform in localized deployment hinges entirely on its ability to translate raw language and scanned guidelines (like an MOHCC PDF) into strict, transparent operational rules that a human can govern with a single tap.

Built With

Share this project:

Updates