# Holes Research Report: Holes 10-18
## Date: 2026-02-14
## Status: RESEARCH COMPLETE -- Awaiting Founder Review

---

# EXECUTIVE SUMMARY

Seven critical adoption and competitive holes were researched across 10 web searches covering: viral developer tool adoption patterns, Ollama limitations, GPU cloud pricing trends, trust barriers for background agents, open source viral growth playbooks, the local inference competitive landscape, and decentralized GPU sharing platforms.

**The single most important finding**: LLMHosts as currently conceived occupies the worst possible market position -- harder to set up than Ollama, less polished than ChatGPT, more friction than cloud APIs, and less earning potential than ShareAI. But there is a clear path forward if the product concept shifts from "orchestrate your GPUs" to **"the missing glue layer between all your AI"** -- combining local, cloud, and shared inference into one seamless experience that no single tool provides today.

**The second most important finding**: ShareAI already exists and does the "share your GPU, earn money" play with 150+ models and a 70/30 revenue split. LLMHosts cannot compete on that axis without significant differentiation.

**The third most important finding**: Claude Code went viral not because of cost savings but because of **visible, immediate, transformative output**. LLMHosts's "save money" pitch is structurally unable to create a viral moment. The product needs a different "holy shit" moment entirely.

---

# HOLE 10: "Install an agent on your PC" is a hard sell

## Research Findings

**The trust landscape (2025-2026):**
- Crypto miners definitively poisoned the "software that uses your GPU and phones home" well
- Successful background agents (Tailscale, 1Password Device Trust, Docker Desktop) overcame this through: (1) cryptographic transparency in updates via The Update Framework (TUF), (2) open-source code for inspection, (3) integration with trusted ecosystems, (4) clear value proposition that justifies the agent
- Tailscale specifically won trust by being an "identity-based network" -- the agent's purpose is immediately clear and the value is instant (secure access to your stuff from anywhere)
- 1Password's Device Trust agent updates hourly, invisibly, using signed binaries with keys stored in hardware security modules -- trust through cryptographic proof, not promises

**Key insight**: The tools that overcame the trust barrier didn't do it through marketing. They did it through (a) being open source, (b) providing instant visible value, and (c) having a purpose so obvious that the agent feels inevitable rather than suspicious.

## Solutions

### Solution 10A: Browser Extension First, Agent Second (Recommended)
**Don't start with an agent.** Start with a browser extension or CLI tool that provides immediate value without any background process. The agent comes later, only when the user has already experienced enough value to want more.

- Phase 1: Browser extension / CLI that connects to existing Ollama instance (zero new software on the GPU side)
- Phase 2: "Upgrade to full agent" unlocks multi-device, Hive Mode, and smart routing
- Phase 3: Agent is now a feature upgrade, not an entry barrier

This mirrors the Tailscale playbook: easy first step (install the app, it just works), then progressively more powerful features (subnet routing, exit nodes, etc.) as trust builds.

### Solution 10B: "Transparent Agent" with Live Audit Dashboard
If the agent is the entry point, make it the most transparent background process ever built:

- **Open source the agent completely** -- not "source available," actually AGPL/MIT
- **Real-time resource dashboard** in system tray showing exactly: GPU utilization %, network bytes sent/received, which model is loaded, who is using it (if Hive Mode)
- **Hardware kill switch**: one-click pause that immediately halts all GPU usage and network traffic
- **Signed, reproducible builds** using TUF (The Update Framework) -- same approach 1Password uses
- **No phone-home by default**: agent works fully offline. Network features are opt-in, one at a time

### Solution 10C: Piggyback on Docker (Already Trusted)
Since the tech stack is Docker-based: ship the agent as a Docker container, not a native binary. Docker Desktop has 20M+ installs and developers already trust container isolation.

- `docker run -d --gpus all llmhost/agent` is less scary than "download and install LLMHosts.exe"
- Container isolation provides actual security boundaries, not just promises
- GPU passthrough (--gpus) is well-understood in the Docker ecosystem
- For non-technical users, ship a Docker Compose one-liner with a web UI

---

# HOLE 11: 10-minute onboarding blocked by model download

## Research Findings

**The download problem is real:**
- Llama 3.1 8B quantized: ~4.7GB (2-4 min at 100Mbps)
- Llama 3.1 70B quantized: ~40GB (30-50 min at 100Mbps)
- DeepSeek v3.1 671B: ~350GB+ (hours)
- Most home connections are 30-100Mbps, not 100Mbps+

**How others solve it:**
- Ollama pre-pulls popular models and uses delta downloads for updates
- LM Studio has a model browser but still requires full download
- Cloud APIs (OpenRouter, etc.) provide instant access -- zero download
- Exo supports distributing model shards across devices, so partial downloads on each machine suffice
- The "paved road" onboarding philosophy says: automate Days 0-2, get to first value before the user understands the system

**Key insight**: The 10-minute promise doesn't need local inference to be true. It needs the user to get value in 10 minutes BY ANY MEANS, then transition to local inference in the background.

## Solutions

### Solution 11A: Cloud-First, Local-Later (Hybrid Onboarding) -- STRONGLY RECOMMENDED
This is the single most important architectural decision for LLMHosts:

1. **Minute 0-1**: Sign up, install CLI/extension
2. **Minute 1-3**: First inference hits a cloud provider (OpenRouter/Together/Groq) through LLMHosts's unified API. User sees instant results. LLMHosts pays for this (pennies per user for initial queries).
3. **Minute 3-5**: Dashboard shows: "You just used cloud inference. Cost: $0.003. Your GPU could do this for free."
4. **Minute 5-10**: Background model download begins. User is ALREADY using the product and seeing value.
5. **Minute 10+**: Local model finishes downloading. Dashboard shows: "Local inference ready! Switching... Cost: $0.00"

The transition from cloud to local becomes the "holy shit" moment (see Hole 13). The user watches their cost drop to zero in real time.

### Solution 11B: Tiered Model Quick-Start
Not everyone needs a 70B model. Offer a "fast start" path:

- **Instant** (< 30 seconds): TinyLlama 1.1B or Phi-3-mini 3.8B (~2GB) -- enough for basic chat, code completion
- **Fast** (2-5 minutes): Llama 3.1 8B Q4 (~4.7GB) -- good general performance
- **Full** (30+ minutes): Larger models download in background

The onboarding wizard should auto-detect GPU VRAM and recommend the fastest-to-download model that will actually run well on their hardware.

### Solution 11C: Peer-Seeded Downloads (Hive Mode Perk)
If a user's friends are already on LLMHosts, download model weights from them over LAN (BitTorrent-style) instead of from the internet. On a gigabit LAN, a 40GB model takes ~5 minutes instead of 30+. This also makes Hive Mode the solution to onboarding friction, not just a feature.

---

# HOLE 12: Awkward middle -- too simple for power users, too complex for casual

## Research Findings

**The market segmentation reality:**
- Power users (run Ollama, know what GGUF means) -- 500K-2M people globally. They don't need LLMHosts.
- Casual users (use ChatGPT, don't know what a GPU is) -- 100M+ people. LLMHosts is too complex for them.
- The "awkward middle" is real, but there's a SPECIFIC underserved segment:

**The underserved segment: "AI power users who aren't ML engineers"**
- Developers using Claude Code, Cursor, Cline, Aider who want cheaper/private inference
- Small teams (2-15 people) who collectively own enough GPU power but can't easily share it
- Creators/streamers who have beefy PCs idle 16+ hours/day
- Privacy-conscious professionals (lawyers, doctors, finance) who need local inference but not ML expertise
- ACTI report shows 69% of professional developers now use AI coding tools -- these people understand the value of inference but don't want to manage infrastructure

**Key insight from Ollama's limitations:**
- Ollama cannot do multi-machine GPU pooling (confirmed -- GitHub issue #9224 is still open)
- Ollama's network API is 40-50x slower than local (GitHub issue #13899)
- Ollama has no built-in auth, no usage tracking, no cost comparison
- Ollama is a single-machine tool trying to pretend it's not

**LLMHosts's real day-one user**: A developer who already uses AI coding tools and wants to (a) stop paying $200/month for cloud API keys and (b) use their existing hardware without becoming a sysadmin.

## Solutions

### Solution 12A: Position as "AI Coding Infrastructure" Not "LLM Host"
The viral moment in AI right now is coding tools. Claude Code has 69% adoption. These users:
- Already understand inference costs (they pay Anthropic/OpenAI monthly)
- Already have dev machines with GPUs
- Already use terminal tools
- Are price-sensitive (many on personal API keys)

**Positioning**: "Run your AI coding tools against your own hardware. Drop your Anthropic bill from $200/month to $0."

This is a narrow wedge but it's the RIGHT wedge because:
- The user already understands the value prop (saves money on something they already pay for)
- The setup is CLI-native (their comfort zone)
- The hardware is already there (dev machines have GPUs)
- The community is active and vocal (developer Twitter/Reddit)

### Solution 12B: "Ollama++" Positioning for Power Users
Don't compete with Ollama. Extend it. Position as:
- "Everything Ollama does, plus multi-machine, plus team sharing, plus cloud fallback, plus cost tracking"
- One-click import of existing Ollama models (no re-download)
- Compatible Ollama API (drop-in replacement for /v1/chat/completions)
- Features Ollama explicitly cannot do: multi-machine inference, GPU pooling across devices, authentication, usage dashboards

### Solution 12C: Two Products, One Platform
Split the product into two entry points:
1. **LLMHosts CLI** (for developers): `pip install llmhosts` → `llmhosts serve` → OpenAI-compatible API on localhost. Power user onramp.
2. **LLMHosts Desktop** (for everyone): Electron app with model browser, chat UI, and "invite friends" for Hive Mode. Casual user onramp.

Both connect to the same Conductor Brain backend. Different packaging, same platform.

---

# HOLE 13: No visible "holy shit" moment on first use

## Research Findings

**What made Claude Code viral:**
- NOT cost savings. It was visible, transformative, immediate output.
- "Take my entire codebase and add dark mode" → watch it happen in real time → dark mode works → "holy shit"
- Non-coders used it to file taxes, book theater tickets, monitor plants
- The output was VISIBLE ARTIFACTS: working code, changed files, running apps
- Key quote from Fortune: Claude Code gave Anthropic "its viral moment" because the value was "instantly visible"

**What makes "save money on inference" NOT viral:**
- Savings are invisible until you accumulate data
- First impression is "it's like ChatGPT but slower" (local models are slower than cloud)
- No shareable output, no screenshot moment, no "look what I made"

**The viral formula**: Visible transformation + immediate + shareable = viral moment

**Key insight**: LLMHosts needs to SHOW something happening that couldn't happen before, not promise savings that might materialize later.

## Solutions

### Solution 13A: "The Cost Ticker" -- Real-Time Savings Visualization (Quick Win)
If the hybrid cloud→local onboarding (Solution 11A) is implemented:

- Show a real-time split-screen during first use:
  - Left: "Cloud cost: $0.003... $0.008... $0.015..." (ticking up)
  - Right: "Local cost: $0.00" (static)
- When local model finishes loading: dramatic visual switch. Cloud cost ticker freezes. Local takes over. Counter starts: "Money saved: $0.001... $0.002..."
- After 1 hour of use: "If you used ChatGPT Plus for this, you'd have spent $20/month. Your cost: $0."
- Make this a **shareable screenshot**: "I saved $X this month by running AI on my own hardware" → Twitter/Reddit gold

### Solution 13B: "Hive Mode Reveal" -- Your Friends' GPUs Appearing Live
When a user's first Hive Mode friend comes online:

- Animated visualization: a new GPU node appearing on a network map
- "Your friend's RTX 4090 just joined. You can now run 70B models. Before: limited to 8B."
- The jump from "my crappy laptop can only run tiny models" to "holy shit I'm running Llama 70B across my friends' GPUs" IS the viral moment
- This is something NO existing tool does. Not Ollama, not ChatGPT, not OpenRouter.

### Solution 13C: "Benchmark Battle" -- Your Hardware vs. The Cloud
On first install, run an automatic benchmark:

- "Your RTX 3070 generates 45 tokens/sec on Llama 8B"
- "GPT-4o on OpenAI: 80 tokens/sec but costs $0.01 per 1K tokens"
- "At your usage rate, you'd save $147/month running locally"
- Comparative leaderboard: "Your setup ranks #3,847 globally"
- Gamification element: "Upgrade to an RTX 4090 to reach top 1,000"

---

# HOLE 14: Hive Mode freeloading problem

## Research Findings

**Academic solutions exist:**
- **Credit fairness** (2026 paper): Tracks cumulative resource contributions over time. Agents who contribute more in early rounds can recoup in later rounds. Achieves fairness + efficiency.
- **SWAP (Swarm Accounting Protocol)**: Peer-to-peer accounting where nodes track bandwidth with peers. When debt crosses a threshold, settlement occurs (token payment or service-in-kind). Used in Ethereum Swarm.
- **ConTrib**: Decentralized work accounting for detecting freeloading and fraud at scale.
- **FairRelay**: Payment channel networks with cryptographic guarantees of fair compensation.

**How similar platforms handle it:**
- ShareAI: 70/30 revenue split (GPU provider gets 70%). Monetary incentive eliminates fairness debate.
- BitTorrent: Ratio tracking. Upload less than you download → throttled speeds.
- Akash Network: Market-based pricing. GPU providers set their own rates.

**Key insight**: Among friends, monetary accounting feels wrong ("you owe me $3.47 of GPU time"). The solution needs to feel like sharing, not billing.

## Solutions

### Solution 14A: "Karma Points" -- Non-Monetary Contribution Tracking (Recommended)
Design a system that feels like sharing, not a marketplace:

- **Karma score** per user: ratio of GPU-hours contributed vs. GPU-hours consumed
- **Visual balance**: simple gauge showing "You've contributed 3x more than you've used" (green) or "You're using more than you contribute" (yellow/red)
- **Soft consequences**: When karma is very low, requests are deprioritized (slower routing, not blocked). When karma is high, priority routing.
- **No real money involved** (for friends mode). The social pressure of visible karma is enough.
- **"Karma forgiveness"**: New members start with a positive balance so they can use the network immediately. Degrades over time if they never contribute.

This mirrors BitTorrent's ratio system, which successfully managed freeloading for 20+ years without any cryptocurrency or payment system.

### Solution 14B: "Contribution Tiers" -- Automatic Fairness Without Accounting
Instead of tracking exact usage, assign tiers based on hardware contributed:

| Tier | Hardware | Access Level |
|------|----------|-------------|
| Seeders | GPU always-on, contributing to hive | Full access to all hive GPUs, priority routing |
| Sharers | GPU available when idle (auto-detected) | Access to hive when contributing |
| Riders | No GPU contributed | Access only when excess capacity exists, lowest priority |

Rules:
- Your access level = your contribution level. Contribute a 4090 → access everyone's 4090s. Contribute nothing → you're last in line.
- Tier is automatic based on uptime/availability, not manually configured
- Transparent: everyone can see who's in which tier in the hive dashboard

### Solution 14C: "Time Banking" -- 1:1 GPU-Hour Exchange
The simplest fair system:

- 1 GPU-hour contributed = 1 GPU-hour you can consume (adjusted for GPU power: 1 hour of RTX 4090 = ~3 hours of RTX 3060)
- Visible balance: "You have 47 GPU-hours banked"
- When balance hits zero: falls back to cloud inference (user pays) or requests queue behind contributors
- Friends can "gift" GPU-hours to each other
- Monthly reset option for groups that don't want to track forever

---

# HOLE 16: OpenRouter could add local GPU support

## Research Findings

**Current competitive landscape (Feb 2026):**
- **OpenRouter**: Cloud API aggregator. 200+ models. No local inference. No announced plans for local GPU support.
- **ShareAI**: Already doing BYOI (Bring Your Own Infrastructure) with "Priority over my Device" toggle. 150+ models. 70/30 revenue sharing. This is the ACTUAL competitor, not OpenRouter.
- **LiteLLM**: Open-source proxy that can route between local and cloud. No orchestration, no multi-device, no Hive Mode.
- **Jan.ai**: Local-first AI with OpenAI-compatible API. Single machine only.
- **Exo**: Distributed inference across consumer devices. 40K+ GitHub stars. Peer-to-peer GPU pooling. No cloud fallback, no routing intelligence, no team features.

**Key insight**: OpenRouter COULD add local GPU support, but they'd be building against their business model (they earn a margin on cloud API calls). Adding local inference cannibalizes their revenue. ShareAI is the actual threat -- they already have the hybrid model.

**Defensive moats available to LLMHosts:**
1. **Exo integration** gives distributed inference across devices -- neither OpenRouter nor ShareAI does this
2. **Conductor Brain** (RL-trained routing) is genuinely novel if executed well
3. **Friend-to-friend sharing** (Hive Mode) is social, not transactional -- different from ShareAI's marketplace
4. **Privacy-first architecture** (OpenZiti/mTLS) is stronger than ShareAI's approach

## Solutions

### Solution 16A: "Integrate, Don't Compete" with OpenRouter
Instead of fearing OpenRouter, use them:

- LLMHosts's Conductor Brain routes to local GPUs first, then falls back to OpenRouter/Together/Groq when local capacity is insufficient
- Users bring their own OpenRouter API key; LLMHosts makes OpenRouter BETTER by adding local-first routing
- This makes LLMHosts the orchestration layer ABOVE OpenRouter, not a competitor to it
- If OpenRouter ever adds local support, LLMHosts is already the intelligence layer that optimizes across both

### Solution 16B: Speed to Market on Exo + Social
The feature combination that nobody else has: **distributed inference (Exo) + social sharing (Hive Mode) + intelligent routing (Conductor Brain) + cloud fallback**.

- OpenRouter can't do distributed local inference
- Exo can't do cloud fallback or social sharing
- ShareAI can't do peer-to-peer friend groups or distributed inference across consumer devices
- Ollama can't do multi-machine

Ship this specific combination fast. The moat is the integration, not any single feature.

### Solution 16C: Open Protocol Strategy
Make LLMHosts's routing protocol an open standard:

- Publish the Conductor Brain routing protocol as an open spec
- Let anyone build compatible agents
- This creates network effects that a closed platform can't match
- Even if OpenRouter adds local inference, they'd have to adopt LLMHosts's protocol or build their own (fragmentation favors the first mover)

---

# HOLE 17: Ollama + Open WebUI is "good enough" for most

## Research Findings

**Ollama's confirmed weaknesses (from GitHub issues and user complaints):**
1. **No multi-machine GPU pooling** -- Issue #9224 still open. Cannot split models across physical servers.
2. **Network API is 40-50x slower** -- Issue #13899. The /v1/chat/completions endpoint is dramatically slower over network vs. local.
3. **No authentication** -- Exposed servers are a security risk. No built-in auth mechanism.
4. **Performance regressions** -- v0.13.2 introduced 10x slower inference in some scenarios, GPU utilization issues.
5. **No usage tracking** -- No dashboard, no cost comparison, no analytics.
6. **No cloud fallback** -- When local GPU is busy or model is too large, there's nothing.
7. **Auto-start without consent** -- Erodes trust, especially on Windows.
8. **Privacy concerns** -- Outgoing network traffic during "local" operations.
9. **No team/sharing features** -- Single-user, single-machine only.
10. **No intelligent routing** -- Can't automatically pick the best model for a task.

**The "good enough" threshold:**
Ollama + Open WebUI gives you: local chat with models, model management, conversation history. That IS 80% for a single user on a single machine who just wants to chat.

**The 20% that Ollama CAN'T do (LLMHosts's value):**
1. Multi-machine inference (pool GPUs from multiple devices)
2. Automatic cloud fallback (when local isn't enough)
3. Cost tracking and optimization (how much am I saving vs. cloud?)
4. Team/friend sharing (Hive Mode)
5. Intelligent model routing (right model for the task, not whatever you last loaded)
6. Security (auth, encrypted connections, audit trails)
7. Integration with AI coding tools (replace your API key, save money)

## Solutions

### Solution 17A: "Ollama Inside" -- Don't Replace, Enhance
The winning move is to make Ollama a COMPONENT of LLMHosts, not a competitor:

- `llmhosts init` detects existing Ollama installation and says: "Found Ollama with 3 models. Importing..."
- Zero re-download. Zero reconfiguration.
- LLMHosts adds: dashboard, cost tracking, cloud fallback, multi-device routing ON TOP of Ollama
- User keeps using Ollama directly if they want. LLMHosts is an orchestration layer.
- Tagline: "Ollama runs your models. LLMHosts runs your AI."

### Solution 17B: Quantify the 20% Gap
Create a public, interactive calculator: "Ollama vs. LLMHosts: What are you missing?"

Input: How many devices? How many users? Monthly cloud API spend? Use cases?
Output: Specific dollar savings, specific capabilities unlocked, specific security gaps closed.

For a solo developer with one GPU: "You're fine with Ollama. Seriously. Come back when you have 2+ devices or want cloud fallback."
For a team of 5 with mixed hardware: "You're leaving $847/month in GPU capacity unused and paying $400/month in cloud APIs. LLMHosts would save you $1,247/month."

**Honesty is a marketing strategy.** Telling people they DON'T need you builds more trust than overselling.

### Solution 17C: "Migration Path" Content Marketing
Create content specifically for the Ollama community:
- "I ran Ollama for 6 months. Here's what I wish it could do." (blog post)
- "Ollama to LLMHosts in 5 minutes" (migration guide)
- "Running Llama 70B across 3 machines with LLMHosts" (demo video that Ollama literally cannot replicate)
- Target r/LocalLLaMA, r/ollama, Hacker News -- these are the exact communities

---

# HOLE 18: Cloud GPU pricing dropping fast

## Research Findings

**The price collapse is REAL and DRAMATIC:**
- H100 rental: $8/hr (late 2024) → $2.85/hr (2025) → spot prices at $0.99-1.49/hr
- Per-token costs dropped 1,000x since 2022
- 300+ new GPU cloud providers entered in 2025 alone
- H200 now enables single-GPU serving of 70B models at $2.15-6.00/hr
- Blackwell architecture promises 30x further inference improvements

**BUT -- Jevons' Paradox is saving the home GPU value prop:**
- Despite 1,000x cost reduction, enterprise AI spending INCREASED 320% ($11.5B → $37B)
- Cheaper inference created new use cases that weren't viable before
- AI coding tools alone drove massive new demand (69% developer adoption)
- Usage per user is expanding faster than prices are falling

**The math for home GPUs:**
- RTX 4090: ~$1,600 purchase price. AI inference earning: $3-7/day. Payback: 7-18 months.
- Cloud H100 at $1/hr for equivalent performance: $720/month.
- For always-on inference (coding tools, personal AI assistant), home GPU ROI is still 5-10x better than cloud.
- Cloud pricing drops help TRAINING costs. For INFERENCE (LLMHosts's market), the key metric is latency, not throughput. Local GPUs have zero network latency.

**Key insight**: Cloud pricing is dropping for BATCH inference and training. For INTERACTIVE inference (chat, coding, real-time), local GPUs win on latency and are still cheaper for sustained use. The risk is real for occasional users but LLMHosts should target habitual users.

## Solutions

### Solution 18A: "Cloud is Your Backup, Not Your Primary" Positioning
Don't fight the cloud pricing narrative. Embrace it:

- "Cloud GPU prices are dropping. Great! Use them as your overflow. Use YOUR hardware as your primary."
- "Local inference: 0ms network latency, $0/token, 100% private. Cloud fallback: available when you need more."
- LLMHosts's value isn't "cheaper than cloud." It's "local + cloud + shared, intelligently routed."
- The Conductor Brain picks the cheapest/fastest/most-private option automatically. Sometimes that's local. Sometimes that's cloud. The USER doesn't have to choose.

### Solution 18B: Track and Prove the Value Over Time
If cloud prices keep dropping, LLMHosts's dashboard should be honest:

- Monthly report: "This month, local inference saved you $X vs. equivalent cloud usage"
- If the number approaches zero: "Cloud is now competitive for your usage. Consider scaling down your local setup."
- This HONESTY builds trust. Users who see you're not locking them in become advocates.
- Meanwhile, the privacy argument stands regardless of price: "Cloud cost: $0.001/token. Privacy cost: priceless."

### Solution 18C: Pivot Value Prop from Cost to Control
If cloud becomes truly cheaper than local, the winning pitch shifts:

- **Privacy**: "Your data never leaves your network. Period. No matter how cheap cloud gets, that won't change."
- **Reliability**: "No API rate limits. No outages. No 'we changed our terms of service.'"
- **Latency**: "Zero network hops. Local inference is physically the fastest possible."
- **Ownership**: "You own your AI stack. No vendor can enshittify it." (Reference: Ollama enshittification article)

---

# SYNTHESIS: WHAT THIS MEANS FOR LLMHOST

## The Product Concept Shift

Based on this research, LLMHosts should evolve from:
> "A platform to orchestrate your GPUs for LLM inference"

To:
> "The intelligent glue between ALL your AI inference -- local, cloud, and shared -- that automatically picks the best option for every request"

## The Day-One User

**Primary**: Developer already paying $100-200/month for AI coding tools (Claude Code, Cursor, etc.) who has a gaming PC or dev workstation with a decent GPU. They want to reduce their bill without managing infrastructure.

**Secondary**: Small team (2-8 people) with collectively strong hardware who want to share compute for AI workflows without paying per-seat cloud pricing.

## The Viral Moment

Not "I saved money." Instead: "I pointed my Claude Code / Cursor at LLMHosts and my cloud bill dropped to zero while inference got FASTER because it's running on my local GPU."

The shareable artifact: a dashboard screenshot showing "$0.00 spent this month" next to "4,000 requests served" with a comparison to what it would have cost on cloud.

## The Competitive Moat

No single competitor has: Distributed inference (Exo) + Intelligent routing (Conductor) + Social sharing (Hive) + Cloud fallback (OpenRouter/LiteLLM) + Privacy (OpenZiti) + Cost tracking (Dashboard).

LLMHosts's moat is the COMBINATION, not any single feature. Ship the combination fast.

## Priority of Solutions

| Priority | Solution | Hole | Impact | Effort |
|----------|---------|------|--------|--------|
| P0 | 11A: Cloud-first hybrid onboarding | 11,13 | Eliminates download blocker AND creates holy-shit moment | Medium |
| P0 | 12A: Position as AI coding infrastructure | 12 | Defines the actual user and wedge | Low (marketing) |
| P0 | 17A: "Ollama Inside" -- enhance, don't replace | 17 | Eliminates the "good enough" objection | Medium |
| P1 | 10A: Browser extension first, agent second | 10 | Removes the trust barrier from onboarding | Medium |
| P1 | 16B: Ship Exo + Social + Routing + Cloud fast | 16 | Creates the combination moat | High |
| P1 | 13A: Real-time cost ticker | 13 | Makes savings visible and shareable | Low |
| P1 | 14A: Karma points for Hive fairness | 14 | Solves freeloading without killing the friend vibe | Medium |
| P2 | 18A: "Cloud is your backup" positioning | 18 | Reframes the cloud pricing narrative | Low (marketing) |
| P2 | 10C: Docker-based agent distribution | 10 | Piggybacks on existing trust | Low |
| P2 | 17B: Honest "Do you even need us?" calculator | 17 | Trust-building marketing | Low |

## The Existential Question

**Should LLMHosts exist as described, or should it pivot?**

The research suggests the core concept is viable BUT the packaging is wrong. The technology components (Exo, LiteLLM, vLLM, OpenZiti, Conductor Brain) are sound. The failure mode is trying to be a platform when the user just wants a tool.

**Recommended pivot**: Start as a CLI tool that developers install via pip. It wraps Ollama, adds cloud fallback, and provides an OpenAI-compatible API. That's it. No agent, no dashboard, no hive mode on day one. Just: `pip install llmhosts && llmhosts serve` → your AI tools now use your GPU first, cloud second.

Hive Mode, the dashboard, the Conductor Brain, the full platform -- those are the future. But they require a user base that the current onboarding cannot create.

**Build the CLI. Get 1,000 developers using it. Then build the platform around them.**

---

## OBSERVATIONS FOR BACKLOG

| ID | Type | Description | Source |
|----|------|-------------|--------|
| OB-013 | OPPORTUNITY | ShareAI is a direct competitor with BYOI and 70/30 revenue model. Competitive analysis needed. | Hole 16 research |
| OB-014 | ARCHITECTURE | Hybrid cloud-first onboarding requires cloud provider API key management and cost subsidy model for free tier | Hole 11, Solution 11A |
| OB-015 | RISK | Ollama v0.13.2 performance regressions may affect LLMHosts if Ollama is used as inference backend | Hole 17 research |
| OB-016 | OPPORTUNITY | Exo's Thunderbolt 5 RDMA support (5-9μs latency) makes distributed inference over local network viable for real-time coding use cases | Hole 16 research |
| OB-017 | STRATEGY | Product positioning should shift from "GPU orchestration platform" to "intelligent AI inference routing CLI" for initial launch | Synthesis |
| OB-018 | FEATURE | Karma/contribution tracking system needed before Hive Mode launch. Academic precedent exists (credit fairness, SWAP protocol, ConTrib) | Hole 14 research |
| OB-019 | RISK | Cloud inference per-token costs dropped 1,000x since 2022 but Jevons' Paradox driving usage up. Value prop shifts from cost to privacy+latency+control over time. | Hole 18 research |
| OB-020 | MARKETING | Viral moment must be VISIBLE ARTIFACT (screenshot of $0 bill, network visualization of friend GPUs joining) not invisible savings | Hole 13 research |
