四十八個德瑞克

ENZO：自託管 AI 工作區，讓您的金鑰與模型直接對接，零中介費用。

derekhsu

本文為 theguysudo/ENZO 之繁體中文翻譯整理，原文版權歸原作者所有。

Quickstart ·
Live demo ·
What's inside ·
Security ·
What's new ·
Usage guide ·
Changelog

Chat with 300+ models. Build agents that write their own operating manuals. Research, generate code, run it all — on your keys, on your infrastructure. When you send a message, the request goes from your browser through ENZO to the provider you picked, and you pay that provider their normal price. Nothing sits in between taking a cut. There is no ENZO account, no usage meter, no subscription.

What's inside

Inside ENZO Count What it gives you
Models in one catalog 300+ across 9 providers, health-checked live
Injectable agent skills 74 bundled domain playbooks the agent loop pulls in per run
Self-drafting agents 2-pass builder plain-English task in, operating manual out
CI pipeline stages 7 including a black-box security pentest on every push
Pentest assertions 44 auth bypass, IDOR, hostile payloads, stream integrity
Unit + security tests 298 agent, vault, crypto and model suites
TypeScript (strict) ~44,000 lines one language, strict mode throughout
Releases 5 v1.0.0 → v1.4.0, everything in the changelog

Quickstart

git clone https://github.com/theguysudo/ENZO.git
cd enzo
docker compose up -d
# → http://localhost:5001

That's the whole install. No accounts, no mandatory env, no database server. Open the app, press Login, and pick any provider:

Provider What you need Free tier
OpenRouter API key many free models
Google AI Studio API key generous free tier
NVIDIA NIM API key free credits
Groq, HuggingFace, Cloudflare, Gemini API key / OAuth varies

Keys are saved encrypted in your browser (passphrase-protected vault, with a recovery file you can download). You can wipe them anytime from the Vault.

On a fresh self-hosted instance the first live-validated key you paste claims the instance — it's written to the container .env and sealed into the enzo-memory volume, so every server-side feature (agents, skills, memory) unlocks immediately and survives restarts. No master key to configure, no setup wizard — paste a working key and go. (Pre-seed a provider key in compose env instead if you'd rather not have the claim window at all; the threat model states this trade plainly.)

Tip

Try it hosted first: https://enzo-hub.duckdns.org — the same app, running on our infrastructure. This repo is exactly that code, minus Google sign-in (self-hosted login is just your provider keys) with a trimmed default theme set for a small download.

Run on Google Colab — zero install

Don't want the local hassle — or want ENZO reachable from any device? The Colab notebook does the whole setup for you: it clones this repo, installs the dependencies, builds the UI and boots the server, then hands you a URL.

  1. Click the button — the notebook opens in Colab (a free Google account is enough).
  2. Run all cells (Runtime → Run all, or Ctrl/⌘ + F9) — install + build takes ~4–5 min the first time; every cell is idempotent, so a re-run reuses what's already there instead of starting over.
  3. Take your URL — the last cell prints two links: a Colab link that works in the browser you're already in, and a Cloudflare tunnel link that works from your phone or any other device (free, no account). The tunnel URL changes each session; the Colab link is bound to your session.

Stays up for the whole session. The notebook arms two disconnect-prevention mechanisms before handing you the URL: a keep-alive that resets Colab's ~90-minute idle timer every 60 seconds while the tab is open, and a watchdog thread that pings the server every 5 minutes and restarts it automatically if it ever dies. Free Colab caps a session at ~12 hours, so a 6-hour run fits comfortably; when a session does end, one click on Run all brings everything back.

Note

The notebook runs on Google's hardware, so Colab's terms apply while you're there — but your model keys stay yours: paste any provider key after boot, exactly like self-hosting, and nothing is ever stored on our side. When the Colab session ends, everything on the VM is gone.

Six surfaces, one workspace

Surface What it does
Terminal Streaming chat with 300+ models — normal, thinking, research and coding modes — with a live ECG-style health trace in the toolbar that flatlines red the moment the catalog is unreachable
Model marketplace One unified catalog across all 9 providers — cards now carry the platform's own cover art and a research panel with real download counts, licences and benchmarks
Music player Search any song and play it in the marketplace — keyless, no YouTube API key — with a 5-band equalizer that actually re-shapes the audio
Agent builder Describe a task in plain English; ENZO drafts the agent's full operating manual, and the agent keeps training itself on your activity from then on
Research mode A deep-research loop that writes its own queries, reads what it finds, and decides when it's done — under hard budgets so it can't burn your key
Code-gen Writes a coding project, boots it, previews it live, and tells you when it's broken
Vault Every key sealed in the browser, attached per-request, wipeable in one click

How the agent builder works

  1. Pass 1 — analysis. A two-pass drafter reads the domain of your task ("an agent that researches MUN country positions") and derives what the manual needs to cover: tacit knowledge, decision heuristics, edge cases.
  2. The race. When a draft needs a model, ~10 free candidates from your own providers fire simultaneously — the first to answer wins, stragglers are aborted, and a brain-health scoreboard reorders future races by which models actually deliver. Dead or rate-limited free-tier models can no longer collapse a draft.
  3. Honest provenance. Every agent records which model actually drafted it — and says so plainly when nothing was reachable.
  4. It doesn't stop. A per-agent neural layer folds in domain-matched platform activity on a 90-second cadence, distills lessons into memory, and injects a live NEURAL FOCUS block into every run. Watch it in the agent's Neural tab.

Why ENZO stands out

Most "AI workspaces" hold your keys, meter your usage, or need a subscription to exist. ENZO is built the other way around:

ENZO Hosted AI apps (ChatGPT, Poe, …) Typical self-hosted AI tools
Who pays the model you, directly to the provider the vendor (plus markup) you
Where API keys live your browser, AES-256-GCM sealed under a non-extractable key vendor's servers server-side env/config
Server reads your keys hosted mode: never — relay-only, CI-enforced. Self-hosted: only the key you explicitly claim, for scheduled agents — stated in the threat model yes usually yes
Middleman fee none subscription / per-seat none
Install docker compose up -d, zero config none (it's hosted) often multi-service setup
Agents improve themselves neural layer learns from your activity no no
Security testing in CI black-box pentest, 44 asserts, every push opaque rarely

(Competitor column is about the category, not specific products — details vary.)

Security

The full threat model is written down — checkable, with the code that makes each claim true — in docs/SECURITY.md. The short version:

What's new in v1.4.0

What's new in v1.3.0 (previous)

Usage guide

macOS

Requirements: Docker Desktop for Mac (Apple Silicon or Intel). Allocate at least 4 GB RAM in Docker Desktop → Settings → Resources (the model catalog + agents like headroom).

git clone https://github.com/theguysudo/ENZO.git
cd ENZO
docker compose up -d

Open http://localhost:5001, press Login, and paste a key from any provider (OpenRouter, Google AI Studio, NVIDIA NIM — all have free tiers; links are in the app). You're in.

Everyday commands

docker compose logs -f          # follow what the server is doing
docker compose restart          # bounce the app, data survives
docker compose pull && docker compose up -d   # upgrade to a new release
docker compose down             # stop (add -v ONLY to wipe all data)

Where your stuff lives: projects, learned skills and agent memory are in named Docker volumes (docker volume ls | grep enzo) — they survive upgrades and down. Your provider keys never touch the server: they're sealed in your browser's vault, and on a fresh install the first key you paste claims the instance for server-side features (scheduled agents).

If the app feels slow on a MacBook: the video themes are GPU-composited; on battery or an older machine, flip the Lite/Full chip (bottom-right) — it swaps video backgrounds for pure shader ones with one click.

Updating: docker compose pull && docker compose up -d. Releases are tagged at github.com/theguysudo/ENZO/releases.

Windows

Requirements: Docker Desktop for Windows with WSL 2 (Docker Desktop's installer sets this up; reboot when it asks). Give it ≥ 4 GB RAM in Settings → Resources.

In PowerShell (no clone folder needed — git comes with Docker Desktop's WSL distro, or use Git for Windows):

git clone https://github.com/theguysudo/ENZO.git
cd ENZO
docker compose up -d

Open http://localhost:5001 in your browser, press Login, paste a provider key — done.

Everyday commands

docker compose logs -f          # follow the server log
docker compose restart          # bounce the app
docker compose pull; docker compose up -d   # upgrade to a new release
docker compose down             # stop (add -v ONLY to wipe all data)

Windows notes

Linux (same everywhere)

git clone https://github.com/theguysudo/ENZO.git
cd ENZO && docker compose up -d   # → http://localhost:5001

What's new in v1.2.0 (previous)

CI

Every push to main runs the full pipeline in .github/workflows/ci.yml — 7 stages:

  1. Security checks — no key literals in tracked files, .env never committed, keys never read from raw localStorage, no onboarding bypasses
  2. Backend — strict TypeScript, every imported file tracked, unit tests (298 assertions across agent, vault, crypto and model suites)
  3. Dependency audits — backend + frontend, fail on any high/critical vulnerability
  4. Black-box security pentest — 44 live assertions against a booted server: auth bypass, hostile payloads, IDOR, stream integrity
  5. Keyless boot proof — the server must boot with zero provider keys
  6. Frontend — strict TS + production build with an enforced gzipped bundle budget
  7. Repo hygiene — no large binaries, changelog and agent docs present

Two editions

latest / lite full
Homepage background Nebula drift — animated WebGL + 8 anime video themes
Workspace/terminal background Default Particles (three.js) + the NYC Subway ride + 9 cinematic video themes
Image download ~150 MB ~470 MB

Both animate by default — the lite themes are GPU shaders, not static images. To get every theme:

ENZO_IMAGE=ghcr.io/theguysudo/enzo:full docker compose up -d

What's stored where

Everything you make lives in Docker named volumes, safe across upgrades:

Your provider keys are not in the volumes — they're browser-side (encrypted at rest with your passphrase).

Optional configuration

Everything works with zero environment variables. A few features want server-side values — put them in a .env next to docker-compose.yml:

# Extra origins allowed to call the API (comma-separated)
ENZO_CORS_ORIGINS=https://enzo.example.com
# "Connect with Cloudflare" OAuth button (optional — pasting a token works too)
CLOUDFLARE_OAUTH_CLIENT_ID=...
CLOUDFLARE_OAUTH_CLIENT_SECRET=...
# HuggingFace OAuth app for the HF onboarding step (optional — token paste works)
VITE_HF_CLIENT_ID=...
HF_CLIENT_SECRET=...

VITE_HF_CLIENT_ID only takes effect when building the image from source (it's baked into the frontend at build time).

Building from source

docker build -t enzo:mine --build-arg THEME_VARIANT=full .

What's different from the hosted deployment

This image is generated from the same codebase that runs https://enzo-hub.duckdns.org, with exactly two feature differences:

  1. No Google sign-in. The hosted site offers Google OAuth as a convenience; here, login is setting your provider keys. Everything else — providers, research, coding agent, vault, memory, skills — is identical.
  2. Default themes (lite image). The first homepage and workspace themes run as pure WebGL/three.js so the image stays small. The full image has the complete set.

License

Apache-2.0 — see LICENSE.

One command. Your keys. No middleman.

docker compose up -d → http://localhost:5001 · or try it live at enzo-hub.duckdns.org

If ENZO saves you a middleman, a ⭐ helps other people find it.

Exit mobile version