Oh My CPA
Oh My CPA gives a CLIProxyAPI gateway a proper control room, where providers, OAuth credentials, client keys, model routing, and the cost of every request are managed and watched from one self-hosted console. You add providers such as Codex, Claude, Gemini, xAI, DeepSeek, Vertex AI, and OpenAI-compatible services, each with credentials, retry and error policies, priority, weight, and an enable switch the gateway actually enforces. OAuth accounts are signed in from the console, with quota window readings, refresh schedules, and per-credential model aliases kept next to the keys they belong to. Client keys can be created, named, and revoked, and those names follow the traffic into request records and filters so you always know which key spent what. The dashboard follows request volume, token throughput, cache hit rate, and cost from the last fifteen minutes out to ninety days, with a year-long token heatmap for the long view. Insights compare keys, models, providers, and credentials against the previous period, while the live routing view shows which credential each request travelled to and whether it was rerouted. Every request stays searchable, with duration, time to first token, token breakdown, and the raw log in a detail drawer. A playground tests any routed model with text and images before your users do. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.
InsForge
With 12,600 GitHub stars and 52 releases in under a year of development, InsForge is the fastest-growing open-source backend platform purpose-built for AI coding agents — giving Claude, Cursor, and any MCP-compatible tool direct access to database, authentication, storage, compute, and AI model infrastructure through a single self-hosted stack. The native MCP server exposes every InsForge operation as callable tools, letting coding agents autonomously create database tables, manage user authentication, upload files, deploy edge functions, and ship complete full-stack applications without human intervention. The Model Gateway provides an OpenAI-compatible API that routes requests across multiple LLM providers (OpenAI, Anthropic, Google, and open-source models) with unified billing, rate limiting, and fallback logic. PostgreSQL with pgvector handles both relational data and vector embeddings for RAG pipelines, while S3-compatible storage manages file uploads and static assets. Edge Functions run serverless TypeScript code on Deno with sub-millisecond cold starts for API endpoints, webhooks, and scheduled tasks. The authentication system provides user management, OAuth2 flows, sessions, and magic links with JWT token handling built in. Site Deployment builds and serves frontend applications with automatic SSL and custom domain configuration. The CLI paired with Agent Skills enables terminal-based workflows where agents invoke InsForge operations directly from the command line. Deploy via Docker with PostgreSQL as the only required external dependency. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.
Sandstorm
Agent code needs somewhere disposable to run, and Sandstorm turns one modest VPS into a fleet of thousands of isolated sandboxes that wake the moment work arrives. You create sandboxes through a plain HTTP API, starting from a registered template or forking a tagged snapshot, with per-sandbox memory ceilings, attached volumes, and egress rules set on each call. Every sandbox is a gVisor container with its own network namespace, so untrusted agent code runs away from your host and away from its neighbors. Idle sandboxes cool down through four tiers, from running hot, to frozen in place with a wake time near ten milliseconds, to checkpointed on disk and back in about a fifth of a second, so a small machine can hold far more sandboxes than it could ever keep running at once. A single binary acts as master, node, and web console: the master tracks desired state and places work across nodes, nodes behind NAT dial out to join the fleet, and a gateway on each node wakes a sleeping sandbox and forwards its traffic automatically. The built-in Hub pulls ready-made snapshot packs for warmed runtimes like Python with numpy or a pre-warmed Playwright browser, skipping cold starts entirely. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.
Mesh LLM
Spare GPUs and memory scattered across many machines become one OpenAI-compatible API for running open models on hardware you already own. Mesh LLM merges a home lab, an office, or a group of friends into a single pool, so existing chat apps and coding agents work unchanged. Start a node, add more later, and the mesh chooses between running a model locally, routing to a peer, or splitting it across several machines when it is too large for one box. Requests are routed by the model name, a virtual model called mesh picks a compatible one for you, and traffic between nodes travels over encrypted QUIC. Private meshes join by invite token and public ones can be discovered, with an API-only client mode for machines that host nothing. A web console shows the node map, model catalog, connected peers, chat with streaming replies, request logs, and a configuration editor. Goose, OpenCode, Claude Code, and Pi launch with one command and use the mesh as their provider, and plugins add extra backends. Releases cover Linux, macOS, and Windows with CPU, CUDA, ROCm, Vulkan, and Metal runtimes, and a headless flag keeps servers tidy. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.
Xinference
Xinference lets a team swap a hosted model API for models running on its own machines, with the same client code and a web console for managing them. The Launch Model page lists 300+ models across language, vision, embeddings, reranking, images, audio, video, and experimental world generation, and a Recommend configuration button fills in engine, size, format, and quantization for your hardware. Custom models, including traditional machine learning models, can be registered beside the built-in ones. Chat models can run on vLLM, SGLang, TRT-LLM, Transformers, llama.cpp, or MLX across CPUs, GPUs, and Apple Silicon. Workers and replicas can be added to serve one large model across several machines. Running Models shows each replica and a built-in chat window, and Performance Tests measure throughput and latency at several concurrency levels, with saved runs to compare. Endpoints speak the OpenAI and Anthropic protocols with streaming and tool calling where a model supports it. API keys, user management, and an audit center cover access control. The interface is available in five languages. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.
ODS
ODS turns a GPU machine or server you already own into a complete private AI stack with a single install command, replacing a shelf of separate tools with one system that serves models, chat, agents, automation, and search from your own hardware. The installer reads your GPU, VRAM, memory, and disk, then downloads a GGUF model matched to that hardware tier, and a compact bootstrap model starts answering within minutes while the full model finishes downloading. From the web dashboard you watch every service's health, ports, and resource use, restart what misbehaves, and check storage and updates without touching a terminal. You chat with local models in Open WebUI, hand background work to the Hermes and Portal agents, and build automations in n8n that connect the stack to more than 400 other apps. Documents you add become searchable knowledge through Qdrant vector storage, so answers cite your files instead of the model's memory. SearXNG and Perplexica answer web questions without trackers or accounts, Whisper transcribes speech, Kokoro reads text aloud, and ComfyUI generates images, all on the same box. Every bundled service is an extension you can enable, disable, or replace, and a Privacy Shield scrubs personal data before anything reaches an optional cloud model through the LiteLLM gateway. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.
AgentField
AgentField is the production backend that makes an AI agent as callable as any other microservice. A Python, Go, or TypeScript function decorated as a reasoner or skill registers with the control plane and instantly becomes a REST endpoint, and agents call each other through the same plane, so every hop is routed and traced. The dashboard summarizes runs, success rate, online agents, and a run timeline, and a Needs attention list surfaces failed runs with a one-click jump into the DAG. The Runs page filters and searches every execution, and a run opens into a step-by-step trace with timings, inputs, and outputs, or a graph of the call tree across agents. Agent Nodes lists each registered service with version, endpoints, and process logs. The Playground executes any reasoner from a form and shows the result and recent runs. Fan-outs run async with webhooks, server-sent events, bounded queues, and backpressure, and a single run may continue for hours. Human approval pauses, canary traffic weights, Prometheus metrics, access policies, and signed provenance records cover governance. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.
OpenMA
OpenMA lets you build and run AI agents with the model, harness, and sandbox you choose, on infrastructure you control, while it handles the sessions, execution, and recovery around them. Create an agent in the console, give it work, and come back later to the same session, because conversation history, streamed progress, and execution attempts are preserved rather than tied to one process that might die. Agents start with shell, file, web, and browser tools, then grow through MCP services and reusable Skills, while resources such as GitHub repositories, uploaded files, and shared memory attach to the work that needs them. Deployments run agents manually or on schedules you define, environments carry their own networking and package configuration, and model cards keep provider settings in one place instead of scattered environment files. If a sandbox fails, the session survives it; a replacement harness can rebuild context from durable events and workspace checkpoints. Operate everything through the console, the API, or the CLI, and plug in the database, queue, and object storage your deployment already trusts. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.
Arkon
With 1,200+ GitHub stars since its April 2026 launch, Arkon provides an enterprise-grade knowledge management layer that turns scattered organizational documentation into AI-accessible structured context. The platform runs as a centralized MCP server, compiling your SOPs, policies, technical docs, and institutional knowledge into a versioned wiki with draft-approval workflows, then serving that wiki to Claude Desktop, Claude.ai, Cursor, and any MCP-compatible client through a single permission-scoped endpoint. OAuth 2.1 with PKCE authentication eliminates manual token management — employees authenticate through a browser login while the system discovers endpoints automatically via RFC 8414. The RBAC v2 system supports custom roles with granular permissions, department-scoped AI Skills, workspace isolation, and comprehensive audit logging so every query and access event is traceable. RAG retrieval powered by pgvector embeddings enables AI clients to search across all organizational documents with source attribution, while the AI Skills system lets teams define reusable instruction sets scoped to specific departments or roles. The architecture runs seven Docker containers coordinated by Compose: PostgreSQL with pgvector for embeddings and metadata, Redis for caching, MinIO for document storage, a FastAPI backend, two ARQ async workers for embedding generation and document processing, and a Next.js frontend portal accessible on port 3119. API keys are encrypted at rest with Fernet, and no telemetry leaves the deployment. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. PolyForm Internal Use licensed.
Mynah
A visitor clicks your link and a face is already there, listening, answering within a fraction of a second, and stopping the moment they interrupt, because Mynah runs live digital humans in the browser instead of playing back rendered video. Underneath, cored takes WebRTC offers, runs the conversation through your chosen language model, speech recognition, and text to speech, and drives a lip synced avatar engine such as MuseTalk, FlashHead, or Wav2Lip, with a semantic end of turn model deciding when a person has finished speaking. The admin console is where you shape the experience: bake a new avatar from a talking video with explicit consent, clone or audition voices, swap avatars per channel without cold starts, and tune green screen keying and gestures live in the playground. Knowledge bases take your documents through ingestion and embedding so answers ground in your material, with retrieval tests before anything ships. Publishing freezes a model, voice, and knowledge snapshot into a channel: a shareable link with token, domain, or CIDR access control, its own branding, and a concurrency cap drawn from an engine pool that computes how many workers your VRAM can hold. Session monitoring shows who is connected and lets you kick a session, health checks watch every dependency, and light and dark themes with Chinese and English interfaces cover both console and visitor pages. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.
Berth
A single GPU can only hold so many models at once, and when a chat server, an image pipeline, and a voice engine all grab VRAM together, somebody runs out of memory and crashes. Berth fixes the scramble by making every engine lease the card: wrap a launch in berth run and the daemon grants memory in turn, queues the rest with an honest place in line and a start estimate, and drains a holder cleanly before the next load begins. The broker learns each engine's real footprint from its runs, so grants are sized by measured peaks instead of guesses, and processes that grab memory without a lease are reported as stowaways, never killed, with contested grants flagged in plain sight. A collisions board counts what the scheduling prevented: avoided collisions, VRAM handed off, drains, stuck releases, and refusals, and every count links back to a gap free event log you can follow live. The Harbor web UI turns that into a departures board of leases, a six hour tide of memory by holder, engine cards with decode throughput and a token ledger, plus a per model leaderboard and thirty days of stored history. Alerts reach your desktop or a webhook, Prometheus scrapes the metrics endpoint, and multi GPU machines can even pass one card through to a VM while the others keep serving. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.
MCPJungle
MCPJungle puts every MCP server your AI tools use behind one endpoint, so Claude, Cursor, Codex, and your own agents all connect to a single gateway instead of a tangle of per-client configurations. Register remote HTTP servers and local STDIO servers once, and their tools, prompts, and resources become discoverable through the gateway in one place. Tool groups expose curated subsets at their own endpoints, so a coding agent sees only the tools its job needs instead of hundreds of irrelevant ones competing for context. The dashboard gives you a visual registry of servers, tools, and groups for everyday management, while the CLI and REST API cover scripting and automation. Development mode runs with zero authentication for a personal setup; enterprise mode adds per-client tokens that allow-list exactly which servers each client may reach. User accounts and manual server initialization give teams a governed shared deployment, with OpenTelemetry metrics showing what clients call and how the gateway performs. Upstream servers can authenticate with bearer tokens or OAuth, so credentials stay centralized in the gateway rather than copied into every client config. Registry data persists in a local file for solo use or in PostgreSQL when the gateway becomes shared team infrastructure. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MPL-2.0 licensed.
Routerly
Routerly is the one front door for every AI model your apps use: point your OpenAI or Anthropic client at it, and it chooses the right model for each request, enforces your budget, and keeps the receipts. Nothing in your code changes except the base URL, and from that moment streaming chat completions and messages flow to OpenAI, Anthropic, Gemini, Mistral, Cohere, xAI or your own Ollama models behind a single token. Nine routing policies score every candidate in parallel: cheapest, fastest, healthiest, most capable, biggest context, least rate-limited, fairest, most budget left, and one that asks a small model to judge which model fits the task. When the winner errors or times out, the next candidate takes over automatically, and the recorded routing trace shows exactly why each model won or lost. Guardrails can block or log content that breaks your rules, and phone numbers, card numbers, SSNs, IBANs and emails can be scrubbed out before anything reaches a provider. Every call is logged with tokens, USD cost and latency, and hard limits per model, project and token reject overspending requests before a provider can charge for them. Projects keep separate tokens, model lists and budgets for each team or tool, role-based permissions decide who may change what, and alerts land in Slack, email, webhooks or PagerDuty when budgets or providers misbehave. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. AGPL-3.0 licensed.
Doorman
Doorman puts one controlled front door in front of every API you run, instead of teaching each service to reinvent keys, quotas, and abuse protection. It routes REST, SOAP, GraphQL, gRPC, gRPC-Web, and AI traffic through a single gateway while its control plane handles the surrounding work. Catalog APIs in a visual builder, configure protocols and endpoints, validate schemas, and manage semantic versions with deprecation and sunset dates as interfaces evolve. Control who may call what through users, roles, groups, and subscriptions, then attach credit tiers and quotas so heavy consumers stay inside the plan you sold them. Slow abusive clients with rate limits, throttling, and bandwidth caps, and keep flaky upstreams from cascading through retries and circuit breaking. Follow every request in searchable logs, review security controls and audit activity, and move configuration between environments with import and export. Start in a self-contained in-memory mode for a small deployment, then switch to shared MongoDB and Redis when several gateway instances need the same counters, revocations, and routing state. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.
Paddler
One binary. A fleet of machines. One calm endpoint for inference. Paddler balances large language model traffic across whatever hardware you already own, instead of renting tokens by the million. The balancer exposes an inference service, a management service, and a web admin panel from a single self-contained program. Agents on separate machines generate tokens and embeddings through slots, each carrying its own context and KV cache. Inference runs on the built-in llama.cpp engine, CPU or GPU. Need a different model? Swap it dynamically, no rebuild, no redeploy. Capacity follows demand: agents join the fleet when traffic grows and leave when it fades, and request buffering holds early work in a queue so scaling up from zero hosts drops nothing. Operators watch fleet health through observability metrics, configure models, chat templates, and inference parameters in the admin panel, and test prompts graphically before users ever see a change. A desktop edition drafts office workstations into service beside the rack servers. For medical, financial, or otherwise sensitive prompts, everything stays inside your own network, and predictable hardware replaces per-token pricing exposure. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache License 2.0 licensed.
OpenGateLLM
One endpoint, every model you run, and a government-grade paper trail for each request. OpenGateLLM sits in front of your AI infrastructure as the single door: applications call one OpenAI-compatible API, and the gateway decides which backend answers, a self-hosted vLLM cluster, an Ollama box in the corner, a Hugging Face TEI embeddings service, or a hosted provider when you allow one. You publish friendly model names as routers and attach real provider APIs behind them, then load-balance across those backends by shuffle or least-busy so a second GPU node starts earning its keep the moment you register it. Chat completions, embeddings, reranking, OCR, and audio transcription each get their standard endpoint, so existing OpenAI SDK code, LangChain, and LlamaIndex projects point at a new base URL and keep working. Governance is built in rather than bolted on: organizations, users, and roles control who may call which model, API keys authenticate every request, and rate limiting keeps one enthusiastic team from eating the whole cluster. Usage monitoring follows every inference, and carbon footprint estimates attach to models through their hosting zone and parameter counts. Retrieval-augmented generation against Elasticsearch or Qdrant plugs into the same surface. No chat history is stored, which is rather the point when the data is yours. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.
FastLLM Proxy
Local vLLM and llama.cpp boxes and hosted providers like OpenRouter, Anthropic, Bedrock, and Gemini all answer to one OpenAI-compatible address once FastLLM Proxy sits in front of them. Clients ask for a frontend model by name, and ordered rules pick the target by caller, prompt size, headers, budget spent, time of day, or how busy a backend is. Prompts that share a prefix return to the node holding their cache, and semantic routing sends coding questions one way and chat another using example prompts you write. API keys carry per-model grants, rate limits, and token or spend budgets, and the management console shows traffic, usage and spend, an append-only audit log, and a fleet topology. Failures fall through to the next target before a byte reaches the caller, and an admission gate turns a flooded engine into a bounded queue. An MCP gateway and an A2A agent endpoint put tool servers and agents behind the same address. Existing LiteLLM configs import unchanged. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.
Huf
Give your team one console to build agents, ground them in real data, and reach them through email, Telegram, Slack, and WhatsApp: Huf is a self-hosted multi-agent AI platform running on servers you operate. Create agents visually, assign each one a provider and model, and watch runs, last activity, and status from a grid that shows every agent at a glance; the same console manages prompts, skills, flows, data tables, and knowledge sources. Connect agents to Gmail and email, Telegram, Slack, WhatsApp, and custom HTTP webhooks, and inbound messages trigger runs whose replies route back to the original channel automatically. Agents read, create, update, and delete any Frappe document, work ERPNext data, and call external systems through Model Context Protocol servers with managed OAuth credentials. Code-heavy tasks run in hardened execution profiles: a local Python environment, an isolated venv, direct SSH, a Frappe SSH connection, or a Docker container, each gated by role-based permissions for agents, tools, data tables, and MCP servers. Teams package prompt templates, tools, and MCP configurations into shareable skills and Huf Apps, run models from cloud providers, or keep everything local with Ollama, LM Studio, or any OpenAI-compatible endpoint. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. AGPL-3.0 licensed.