Hydite — Your software team, in an IDE

An AI-Native IDE: parallel agents · local-first · design and code unified · model-agnostic · in private beta

Hydite is not yet another "AI autocomplete". If you only want Tab-suggestions, the market already has a dozen tools that do that.

Hydite is built around a different idea: fit an entire software team inside your IDE. The whole pipeline — PM scoping the spec, designer drafting the UI, frontend wiring the components, backend writing the API, QA generating tests, SRE chasing incidents — collapsed into a single workspace where multiple agents run in parallel and you command them in plain language.

Status: Hydite is currently in Private Beta. Every capability described below is already shipped; access is gated by Hydite OAuth invites.

1. What is Hydite#

In one sentence:

Hydite is an AI-Native IDE. It bundles parallel agents, semantic code understanding, a visual design canvas, on-device debugging and a local Assistant into a single workspace — local-first, model-agnostic, and a natural fit for your existing engineering flow (Git, CI, MCP, terminals).

Concretely, treat it as a superset of the tools you already use:

Putting all of these into the same workspace, with cross-tool collaboration baked in — that's the whole ambition.

2. Design philosophy#

Hydite is built around four convictions:

❶ Not autocomplete — agents are first-class#

Mainstream AI coding tools are "press-and-suggest". Hydite frees agents from the chat box:

• One sentence kicks off N agents that run in physically isolated Git worktrees — no more single-threaded queuing.
• Long jobs go to a cloud scheduler — keep running while your laptop is closed, results stream back when you're online.
• Agents can call workflows, skills and MCP tools — not just discussing code, actually doing the work.

❷ Parallel > serial#

One human can only do one thing at a time. Ten agents can do ten things.

Five agents, five jobs at once — A implements, B writes tests, C drafts docs, D refactors, E fixes a bug. Physically isolated Git worktrees mean they never step on each other. They merge back through a unified review; rolling back any failure is as cheap as closing a browser tab. A serial 1-hour job becomes a parallel 10-minute job.

❸ Local-first + privacy-first#

Your code never leaves your machine by default.

Compliance is the real reason most teams can't adopt cloud AI IDEs. Hydite ships three privacy tiers:

Every agent tool call runs in a sandbox by default (macOS Seatbelt / Linux namespaces); sensitive directories must be explicitly allowlisted. Agents physically cannot rm -rf /.

❹ Design and code, one source of truth#

UI/UX shouldn't live in another Figma tab. Hydite's Design Hub brings it back into the IDE:

• 60+ design systems out of the box (Apple HIG, Airbnb DLS, Binance, Material 3, …).
• Drag components, tweak tokens, generate code — all on a canvas inside the IDE.
• Edit code → design updates. Edit design → code updates. One source of truth.

3. Four primary pillars (+ one local companion)#

1
Hydite
2
   ┌──────────┬──────────┬──────────┬──────────┐
3
   ▼          ▼          ▼          ▼          ▼
4
Agent Hub  Context Hub  Design Hub  VPhone   ← Four primary pillars
5
   │          │          │          │
6
   └──────────┴──────────┴──────────┘
7
                  ▲
8
          ┌───────┴───────┐
9
          │ Local Assistant │   ← Always-on companion (local-by-default, optional cloud)
10
          └────────────────┘
11
                  │
12
        Model-agnostic · Local-first · MCP-native

3.1 Agent Hub — parallel work, on tap#

3.2 Context Hub — agents that actually understand your code#

Plenty of tools claim "code understanding" — most just stuff the current file into a prompt. Hydite's Context Hub does more:

• Semantic indexing: project-level vectors that describe behaviour, not keyword matches.
• Cross-file tracing: from API call → implementation → tests in one hop.
• Change-impact analysis: before you edit a function, see who calls it.
• Long-context routing: super-long contexts auto-route to Gemini 3.1 / Kimi K2.6 with million-token windows.

3.3 Design Hub — design systems live in the IDE#

3.4 VPhone — real devices inside your IDE#

The black box of mobile debugging is finally cracked open:

• Android / iOS device bridge: USB-plug, and the IDE can read logs, take screenshots, tap, capture network.
• Agent-readable device context: crash repro, UI automation, perf analysis — all scriptable.
• Record-and-replay: turn a manual session into a reusable test case.
• Multi-device parallel: connect several real devices and run regression in parallel.

3.5 Hydite Assistant — always-on local companion (not the headline)#

Assistant isn't the protagonist; it's the always-on companion in the side panel while you drive Agent Hub / Context Hub:

• Fully local: ships local-by-default, project context never leaves your machine — fits any privacy posture.
• Optional cloud version: opt in to cloud Assistant for top-tier models and cross-device sync.
• For lightweight tasks: explain a snippet, look up an API, answer a syntax question, generate a commit message — hand the heavy lifting to Agent Hub.

4. Foundation layer#

Three "ground-floor" capabilities under the four primary pillars + Assistant:

4.1 Model-agnostic#

Hydite locks you into no vendor. Through the Hydite Vtslx AO gateway, dozens of providers worldwide — one key, with routing, fallback, rate limits and billing baked in.

Global flagships#

China-native#

Open-source & specialised#

Pick the right brain per task — never work for one vendor's roadmap. Full catalogue and same-alias fallback routing in the Vtslx AO API Reference.

4.2 Local-first#

4.3 Native MCP#

Model Context Protocol is the "USB standard" for AI agent tooling. Hydite supports it natively — hundreds of MCP servers work out of the box:

• Payments / commerce: Stripe, PayPal, Lemonsqueezy
• Data / backends: Supabase, PostgreSQL, Redis, MongoDB
• Collaboration / docs: Figma, Feishu, Notion, Slack, Linear
• DevOps: GitHub, GitLab, Sentry, Datadog
• Content: Web Search, Brave, Perplexity, AutoGLM

You can also register an internal MCP server with one line of config, exposing your in-house systems to agents.

5. Deployment modes#

Hydite ships four deployment modes for different compliance postures:

5.1 High Privacy mode#

1
Your machine
2
├─ Code      ← stays local
3
├─ Index     ← local vector store
4
├─ Models    ← local inference (Ollama / vLLM / private GPUs)
5
├─ Assistant ← fully local
6
└─ Agents    ← local sandbox execution

Zero egress. Use for finance, government, healthcare, defence.

5.2 Standard mode#

1
Your machine                          Cloud
2
├─ Code   → only essentials (encrypted) ─┘
3
├─ Index  ← built locally               ↓
4
├─ Models ← cloud routing ←             │
5
└─ Agents ← local sandbox               │
6
                              (Hydite Vtslx AO gateway)

Cloud models accessed via Hydite Vtslx AO; only essential snippets leave your machine, encrypted in transit. The default for ~99% of commercial projects.

5.3 Team mode#

A whole team shares one self-hosted Hydite Vtslx AO gateway:

• Unified API key governance (API Key Groups).
• Unified rate limits and budgets (Rate Limiting).
• Unified audit and compliance logs.
• Shared skills, workflows and design systems across the team.

5.4 Enterprise self-hosted#

Every component runs inside your network:

• IDE client + agent scheduler + model gateway + index service — fully on-prem.
• Integrates with your SSO / LDAP / private CA.
• See Dedicated Instance.

6. Who uses Hydite#

7. How Hydite differs#

Hydite's edge isn't a single killer feature — it's a complete workspace: editor + parallel agents + design + devices + governance + privacy, all in one IDE.

8. Getting started#

Beta access: Hydite is invitation-only via Hydite OAuth. All you need is a Hydite Vtslx AO account — no GitHub / Google / email required.

5-minute first taste#

1. Download Hydite (macOS / Windows / Linux).
2. Click Sign in with Hydite — the browser handles the OAuth handshake against your Hydite Vtslx AO account.
3. Open any project — Hydite auto-builds a semantic index.
4. ⌘ K to summon the local Assistant. Say: "Walk me through this project."

30-minute migration from your current IDE#

1. One-click import from VS Code / JetBrains (settings, keymaps, extensions).
2. Pick a privacy mode in Workspace → AI Settings.
3. Enable 1–2 skills in the Agent Hub (start with code-essentials and git-essentials).
4. Dispatch your first parallel agent: "Replace every console.log in this folder with logger.debug."

1-hour team rollout#

1. Deploy a Hydite Vtslx AO gateway shared by the team.
2. Configure API Key Groups for frontend / backend / CI.
3. Set Rate Limiting — quotas and budgets.
4. Codify 3–5 high-frequency workflows into skills; new hires get them on day one.

9. Documentation map#

Every capability below already ships in the Hydite beta; the corresponding docs are being written:

In one line#

Hydite fits a software team into an IDE. You're not using a completion tool — you're commanding a 24×7 engineering organisation that runs in parallel, stays compliant, and never locks you to a vendor.

Next: Agent Hub — parallel agent guide (rolling out during the beta).