Why I Built My Own AI: The Case for Self-Hosted Domain Agents

The premise that broke for me

For about eighteen months I lived inside the OpenAI / Anthropic ecosystem like everyone else. ChatGPT for general queries, Claude for code, a couple of Zapier integrations gluing it all together. It was fine. I shipped products. I got things done.

Then a few things piled up at once:

• OpenAI deprecated three model versions in a single quarter. Prompts that had been stable for nine months suddenly produced different outputs. Apps I'd built started misbehaving in ways that were hard to debug because the model itself was different.
• I noticed I was paying close to $400/month across personal + work API usage. The unit economics didn't scale for the things I wanted to build long-term.
• A friend got rate-limited mid-presentation by Anthropic because they hit a daily cap they didn't know existed. The "always available" assumption that makes AI useful as infrastructure was, in fact, available at someone else's discretion.
• I started building accessibility software for my dad and clinical software for my kid's therapist. For both, "send the user's voice to OpenAI" was a non-starter for product reasons. Once I'd done the on-device work for those, the "we have to use cloud" thinking for everything else stopped making sense.

The breaking point was simple: I wanted an AI that would still work in five years exactly the way it works today, on hardware I own, that I could point at any task without asking anyone for permission. That product didn't exist. So I built it.

What Kulvex actually is

Kulvex is a self-hosted AI platform. Three pieces:

1. The server — runs on your own hardware (a workstation with at least one 24GB GPU, ideally two). Hosts a quantized 80B-parameter model via llama.cpp, exposes a Socket.IO API for clients, and orchestrates a set of domain agents.
2. The iOS client (in App Review as of writing) — talks to your Kulvex server over a private endpoint. Has Apple Foundation Models on-device for low-latency tasks, falls back to the server for anything requiring the 80B model.
3. Kulvex Code — terminal IDE with 15+ plugins that builds on the same server. Sibling product to KCode (the security audit tool), but for general dev work.

The server is the brain. Everything else is interfaces to it.

The 17 domain agents

"AI assistant" is too vague to be useful. What Kulvex actually does is split work across specialized agents, each tuned for one job. The current set:

Each agent has a narrow job, its own toolset, and its own context budget. When the user says "turn off the kitchen lights and tell me what's on the calendar tomorrow," the platform routes to two agents in parallel — the Lights agent fires the Zigbee command, the Calendar agent pulls events from CalDAV — and the orchestrator stitches the response. Neither agent needs to know about the other.

This is the design that made Kulvex tractable for me as a solo developer. The general-purpose "do everything" AI model is hard to make good. Seventeen narrow agents, each replaceable independently, is much easier to ship and maintain.

The piece I'm proudest of: self-evolution

One of the 17 agents is called Self-Evolution. Its job is to read Kulvex's own codebase, identify bugs or improvements, write the fix, run the test suite, and — if everything passes — commit and deploy.

This sounds reckless. It mostly isn't, because of three constraints:

1. The Self-Evolution agent runs in a sandboxed worktree, never directly against the main branch. Changes get applied to a clone, tested in isolation, and only merged if a full CI pass succeeds.
2. I review every commit. Self-Evolution opens PRs against my GitHub; nothing lands without human approval. The agent doesn't have write access to main.
3. Scope is bounded by directive files. The agent reads OWNER-DIRECTIVES.md at the root of the repo, which tells it what it's allowed to modify (typo fixes, dead code removal, small refactors that don't change semantics, dependency upgrades) and what it's NOT (anything touching auth, payments, model selection logic, API surfaces).

In the four months it's been running, Self-Evolution has opened ~340 PRs against the Kulvex codebase. I've merged about 280 of them. The rest were rejected — usually because the agent misread the directive scope, or because the fix was technically correct but stylistically inconsistent with how I write things. The net effect: a meaningful chunk of the maintenance burden of a 200K+ line codebase is offloaded.

I wrote more about how this works in detail on the Kulvex blog.

The hardware reality

I'm not going to pretend Kulvex is free to run. Self-hosted AI in 2026 means buying GPUs. The current production setup at my office:

• RTX 5090 (32 GB VRAM) — primary inference card. Runs the 80B-parameter model in 4-bit quantization.
• RTX 4090 (24 GB VRAM) — secondary card. Handles the speech recognition models (Whisper-large) plus vision tasks (image captioning, OCR on cameras).
• 96 GB DDR5 system RAM, mainly for context cache and operational overhead.
• ~$5,500 total hardware cost for the workstation. Three-year amortization puts it at $155/month — less than half what I was paying OpenAI alone.

The math gets better the more you use it. The hardware costs the same whether I run 10 queries or 10,000. After the breakeven, marginal cost approaches zero.

For users who don't want to run their own GPU, Kulvex has a hosted "Home" tier where we run the server on shared infrastructure — still no cloud LLM vendor in the loop, the model weights are pinned, but you're renting compute instead of buying. The hosted option exists for people who want the experience without the workstation.

To see what your hardware is actually doing while running this kind of workload, I built SiliconMon for Mac users (the macOS equivalent — most folks running Kulvex servers on a Mac Studio use it to monitor GPU + ANE residency). For Linux/CUDA setups, nvtop and NVIDIA Nsight remain the standard.

What I don't have to give up

One thing that surprised me about going self-hosted: I didn't have to compromise on capability for any of my daily tasks.

The 80B-parameter model running on the RTX 5090 produces output that, for the tasks I throw at it (code review, drafting, knowledge retrieval, agent orchestration), is roughly comparable to GPT-4-class models. It's not better than the frontier — Claude Opus 4.x and GPT-5 still beat it on hard reasoning tasks. But for the 95% of work that's pattern matching, structured generation, and tool use, the local 80B is more than enough.

The 5% where the frontier matters, I have the option to fall back: Kulvex's agent orchestrator can route specific tasks to Claude or GPT if the user opts in. But by default, everything stays local. I rarely turn that fallback on. The cost / latency / privacy trade isn't worth it for me.

What I did have to give up

Honest list of where the experience is worse than ChatGPT:

• Setup is harder. A Kulvex server takes 30-60 minutes to install if you're comfortable with Docker and CUDA. Not great for non-technical users. The hosted tier exists for this reason.
• Cold starts. When the GPU has been idle and you ping it, the first response takes 5-10 seconds while the model loads back into VRAM. Subsequent queries are sub-second. The fix is to keep the server warm, which costs idle power.
• Image generation. The current Kulvex setup doesn't include image generation. If you need DALL-E-quality images, you have to fall back to a hosted service. ComfyUI integration is on the roadmap.
• Internet research. The local model doesn't have live web access (by design). For things requiring current information, an agent fires a search query to a local search index or, optionally, to Perplexity / SearXNG. Not as smooth as ChatGPT's built-in browsing.

These are real trade-offs. For people who use AI for casual tasks 3-4 times a day, the cloud is still the better choice. Kulvex makes sense once you're heavy enough on AI usage that the privacy + cost + reliability balance flips.

Pricing

Four tiers, designed around how much hardware ownership you want:

• Starter — free, hosted, capped usage. Try the platform without commitment.
• Home — $19/month hosted, unmetered for personal use, no GPU required.
• Pro — $49/month hosted + on-prem option, full agent suite, priority model updates.
• Enterprise — custom, on-prem with support SLA, single-tenant deployment, integration help.

The on-prem tier is the "I'll run it myself" option — you download the server, get a license key, the platform never phones home for anything except license validation. Pricing reflects support and pattern updates, not gated capability.

The honest part

Same honesty I applied to KCode's revenue and ClearCaps' early traction:

• Kulvex's iOS client is in App Review right now, build 4.3.6. Apple has rejected previous builds for AI consent flow issues — we resolved them and are back in the queue.
• Real users on the Home and Pro tiers exist but the numbers are small. Less than what would make this a sustainable business yet.
• The technical platform is mature. The product / GTM is still finding its shape. The biggest gap right now is the install-and-onboard flow for non-technical users — the platform works, but the first 10 minutes of getting started are clunky.
• I use Kulvex personally every single day. That's the proof for me that the thing is real. Whether it's a business — same as KCode, we'll know in two quarters.

Who this is for

• People who already self-host things. If you run Home Assistant, Nextcloud, Jellyfin, or any homelab software, Kulvex slots into the same workflow. It's just AI in your stack instead of someone else's.
• People with privacy or compliance constraints (healthcare, legal, defense, EU GDPR) that make cloud AI a non-starter.
• People who use AI heavily enough to feel the cost / control gap. If you spend $50+/month on AI APIs, the math probably already favors Kulvex.
• People who care about the principle — that intelligence as software should be ownable, not rented. That's not for everyone, and I'm careful not to wrap it in ideology, but it's a real preference some users have.

— Bruno Aiub, founder, AstroLexis LLC. If you self-host or are considering it, write — I read every email: contact@astrolexis.space.