DEV Community

HyperNexus
HyperNexus

Posted on

How I Built a Universal AI Control Plane (And Why You Need One)

#ai

# How I Built a Universal AI Control Plane

## The Problem

Every AI tool has its own config. Its own memory. Its own way of doing things.

I was switching between Claude for code review, GPT for documentation, Gemini for research, and
Ollama for local testing. Each one needed:

  • Separate API keys
  • Separate tool configurations
  • Separate memory contexts
  • Separate workflows

It was a mess. Context got lost between switches. Tool configs were duplicated. And forget

about keeping memory consistent across providers.

## The Solution

I built HyperNexus — a Universal AI Control Plane that connects to ALL of them through a

single MCP (Model Context Protocol) server.

Instead of configuring separate memory and routing for each AI client, you run one unified

server. It handles:

  1. Progressive Tool Routing — Only injects the top 3 relevant tool schemas per prompt, preventing token bloat
  2. LLM Waterfall — Auto-failover between providers when rate limits hit
  3. Persistent Memory — SQLite + sqlite-vec for semantic search that survives restarts

## Architecture


 ┌─────────────────────────────────────────────┐
 │              HyperNexus Core                │
 ├─────────────────────────────────────────────┤
 │  ┌─────────┐  ┌─────────┐  ┌─────────┐    │
 │  │ Claude  │  │  GPT    │  │ Gemini  │    │
 │  └────┬────┘  └────┬────┘  └────┬────┘    │
 │       │            │            │          │
 │       └────────────┼────────────┘          │
 │                    ▼                       │
 │            ┌──────────────┐                │
 │            │  MCP Router  │                │
 │            └──────┬───────┘                │
 │                   ▼                        │
 │         ┌─────────────────┐                │
 │         │  Tool Registry  │                │
 │         │  (11K+ servers) │                │
 │         └─────────────────┘                │
 │                   ▼                        │
 │         ┌─────────────────┐                │
 │         │  L1/L2 Memory   │                │
 │         │  (sqlite-vec)   │                │
 │         └─────────────────┘                │
 └─────────────────────────────────────────────┘
Enter fullscreen mode Exit fullscreen mode

The Go backend handles 446 HTTP handlers with goroutines for concurrent tool execution. The

TypeScript frontend provides the dashboard for monitoring and configuration.

## Progressive Tool Routing

The biggest problem with MCP servers is token bloat. Dump 50 tool schemas into every prompt and
you've wasted half your context window before the conversation even starts.

Progressive routing solves this:

   func (r *Router) GetTools(prompt string) []Tool {
       // Get embeddings for the prompt
       embeddings := r.GetEmbeddings(prompt)

       // Rank all available tools by relevance
       tools := r.RankTools(embeddings)

       // Return only top 3
       if len(tools) > 3 {
           return tools[:3]
       }
       return tools
   }
Enter fullscreen mode Exit fullscreen mode


plaintext

This cut token usage by 60% in our testing while maintaining 95%+ tool selection accuracy.

LLM Waterfall

Rate limits are inevitable. The waterfall pattern handles them gracefully:

   Primary API (Claude)
       ↓ rate limited
   OpenRouter (backup)
       ↓ rate limited
   LM Studio (local)
       ↓ still failing
   Ollama (last resort)
Enter fullscreen mode Exit fullscreen mode


go

Zero config, zero downtime. Your agents never see the failures.

Persistent Memory

Most agent frameworks forget everything on restart. We use SQLite + sqlite-vec for semantic

search:

   // Store memory with vector embedding
   func (m *Memory) Store(key string, value string) error {
       embedding := m.GetEmbedding(value)
       _, err := m.db.Exec(
           "INSERT INTO memories (key, value, embedding) VALUES (?, ?, ?)",
           key, value, embedding,
       )
       return err
   }

   // Semantic search across memories
   func (m *Memory) Search(query string, limit int) []Memory {
       embedding := m.GetEmbedding(query)
       // Use sqlite-vec for cosine similarity
       rows, _ := m.db.Query(
           "SELECT key, value FROM memories ORDER BY vec_distance_cosine(embedding, ?) LIMIT ?",   
           embedding, limit,
       )
       // ...
   }
Enter fullscreen mode Exit fullscreen mode

14,726 memories stored locally. Zero cloud dependency.

Works With Everything

HyperNexus works with:

  • Claude Desktop
  • Cursor
  • Codex
  • Gemini CLI
  • Windsurf
  • Copilot

One config, six environments. Byte-for-byte identical tool signatures.

Try It Yourself

Open Source (TormentNexus)

Enterprise (HyperNexus)

What's Next

We're working on:

  • Enterprise SSO/RBAC
  • More MCP server integrations
  • Performance improvements
  • Better documentation

What Do You Think?

What's your biggest challenge with AI tooling right now? Is it:

  • Tool configuration?
  • Memory persistence?
  • Provider management?
  • Something else?

Let me know in the comments — I'd love to hear how you're solving these problems.

────────────────────────────────────────────────────────────────────────────────

If you found this useful, star the repo on GitHub: https://github.com/HyperNexusLLC/hypernexus

Top comments (0)