GitHub - theguysudo/ENZO: Self-hosted AI workspace with agents, skills, and tools (Gmail, Calendar) that runs entirely on your own provider API keys (BYOK). Bring your own keys — Groq, OpenRouter, NVIDIA, Hugging Face, Google AI. · GitHub

Skip to content

Navigation MenuSign inAppearance settingsPlatformAI CODE CREATIONGitHub CopilotWrite better code with AIGitHub Copilot appDirect agents from issue to mergeMCP RegistryIntegrate external toolsDEVELOPER WORKFLOWSActionsAutomate any workflowCodespacesInstant dev environmentsIssuesPlan and track workCode ReviewManage code changesCode QualityEnforce quality at mergeAPPLICATION SECURITYGitHub Advanced SecurityFind and fix vulnerabilitiesCode securitySecure your code as you buildSecret protectionStop leaks before they startEXPLOREWhy GitHubDocumentationBlogChangelogMarketplaceView all featuresSolutionsBY COMPANY SIZEEnterprisesSmall and medium teamsStartupsNonprofitsBY USE CASEApp ModernizationDevSecOpsDevOpsCI/CDView all use casesBY INDUSTRYHealthcareFinancial servicesManufacturingGovernmentView all industriesView all solutionsResourcesEXPLORE BY TOPICAISoftware DevelopmentDevOpsSecurityView all topicsEXPLORE BY TYPECustomer storiesEvents & webinarsEbooks & reportsBusiness insightsGitHub SkillsSUPPORT & SERVICESDocumentationCustomer supportCommunity forumTrust centerPartnersView all resourcesOpen SourceCOMMUNITYGitHub SponsorsFund open source developersPROGRAMSSecurity LabMaintainer CommunityGitHub StarsArchive ProgramREPOSITORIESTopicsTrendingCollectionsEnterpriseENTERPRISE SOLUTIONSEnterprise platformAI-powered developer platformAVAILABLE ADD-ONSGitHub Advanced SecurityEnterprise-grade security featuresCopilot for BusinessEnterprise-grade AI featuresPremium SupportEnterprise-grade 24/7 supportPricingSearch/Sign inSign upAppearance settings

You signed in with another tab or window. Reload to refresh your session.
You signed out in another tab or window. Reload to refresh your session.
You switched accounts on another tab or window. Reload to refresh your session.

Dismiss alert

theguysudo

/

ENZO

Public

Notifications
You must be signed in to change notification settings

Fork
15

Star
68

Code

Issues
0

Pull requests
0

Discussions

Actions

Projects

Security and quality
0

Insights

Additional navigation options

Code

Issues

Pull requests

Discussions

Actions

Projects

Security and quality

Insights

mainBranchesTagsGo to fileCodeOpen more actions menuLatest commit History41 Commits41 CommitsFolders and filesNameNameLast commit messageLast commit date.github/workflows.github/workflows  docsdocs  iconicon  notebooksnotebooks  scriptsscripts  skills-bundledskills-bundled  srcsrc  synthetic-naturesynthetic-nature  teststests  traffictraffic  .dockerignore.dockerignore  .env.example.env.example  .gitignore.gitignore  DockerfileDockerfile  LICENSELICENSE  README.mdREADME.md  TRAFFIC.mdTRAFFIC.md  docker-compose.ymldocker-compose.yml  docker-entrypoint.shdocker-entrypoint.sh  index.tsindex.ts  package-lock.jsonpackage-lock.json  package.jsonpackage.json  security-implementation-log.mdsecurity-implementation-log.md  skills-lock.jsonskills-lock.json  tsconfig.jsontsconfig.json  View all filesRepository files navigationREADMEApache-2.0 licenseSecurityMore itemsENZO

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.)
TipTry 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.

Click the button — the notebook opens in Colab (a free Google account is enough).
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.
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.
NoteThe 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

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.
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.
Honest provenance. Every agent records which model actually drafted it — and says so plainly when nothing was reachable.
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:

Keys are sealed in your browser with AES-256-GCM under a non-extractable WebCrypto key. It can be used to decrypt your keys while never being copied — no JavaScript can export its bytes, ours or an attacker's. Optional passphrase mode re-seals everything under PBKDF2-SHA256 (600,000 iterations) and deletes the device key entirely.
One module touches key storage, and CI enforces it. A pipeline stage greps the frontend for any raw localStorage key read and fails the build on a hit — a missed key-access site is a red build, never a production bug.
Every push runs a 44-assertion black-box pentest against a booted server — auth bypass, hostile payloads, IDOR, stream integrity — plus a keyless-boot proof: the server must start with zero provider keys. That's the BYOK guarantee, tested, not promised.
The limits are stated up front. Self-hosted mode stores the first key you claim in the container .env (sealed in the memory volume) so scheduled agents can run while your browser is closed — that trade is documented, not hidden. docs/SECURITY.md covers what's protected, what isn't, and why.

What's new in v1.4.0

In-chat file converter — attach a PDF, spreadsheet, CSV, JSON, TXT or Markdown file in the terminal chat and it's parsed to real text/rows in your browser (files never leave the device; only the reasoning step uses your own key, like normal chat). The agent extracts, merges, or cross-converts — and CSV / Excel download buttons appear right on the reply. Built for research papers: "extract every table and merge into one CSV" now works end to end, and scanned PDFs report their missing text layer instead of failing.
Run it on Google Colab — one click on the Open In Colab button (see Run on Google Colab): the notebook clones, installs, builds and boots ENZO on Google's hardware, hands you a URL for your browser plus a tunnel URL for your phone, and arms a keep-alive + watchdog so it stays up for 6+ hours.
Self-healing Docker pulls — the container now verifies its dependencies on every start and installs anything missing before the server boots (ENZO_AUTO_INSTALL=0 to skip). A pulled image can't boot broken.

What's new in v1.3.0 (previous)

Music player — search any song and play it straight from the marketplace, keyless (no YouTube API key, no quota): a collapsed corner pill expands into a full player card — vinyl disc hero, queue walking, shuffle/loop/like, keyboard controls. For You turns your own listening history (kept device-local) into song seeds through your own provider key.
Real equalizer — a 5-band Web Audio EQ (bass / low-mid / mid / presence / air, ±12 dB, preamp, five presets) that genuinely re-shapes the frequency response when you opt in. Enhance starts off — normal playback is untouched. Tracks the enhancer can't stream fall back to the YouTube engine automatically; playback never breaks.
Marketplace, redesigned — every model card now carries the platform's own cover art, brand colour on hover, live health dot + latency, and a research panel with real facts: HuggingFace download counts, licences, knowledge cutoffs, Artificial Analysis scores and a Wikipedia-backed family summary — pulled keyless from public endpoints, never guessed.
NYC Subway theme — the workspace's new flagship backdrop: an AI-animated subway ride through a tunnel, with a handheld-camera tremble, monochrome film grade and animated recording grain added in code (the video ships clean).
A quieter interface — the whole workspace went monochrome + a single coral accent: the terminal toggle switch rebuilt (was a 385-line component with dead animations), the weather chip moved up beside the catalog header, the nav collapses on scroll and springs back, and the top bar got a cursor-reactive dot grid.
Previously in v1.2.0: the terminal health ECG, the onboarding stepper, ambient weather, the smoke top bar.
Full history: docs/CHANGELOG.md.

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

If http://localhost:5001 doesn't load, check Docker Desktop is running (whale icon in the system tray), then docker compose ps — the port is listed there.
Anti-virus software occasionally slows the first boot (image extraction). The second start is fast.
Everything else — volumes, keys, the Lite/Full chip — works exactly as on macOS.

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)

Live terminal health ECG — the static ONLINE label is now a heart-monitor trace sweeping the terminal toolbar; reachable catalog keeps it beating, anything else freezes a red flatline.
Onboarding, rebuilt — an animated stepper walks the three connect-provider steps (numbers morph into checkmarks, completed steps are click-back-navigable), with a liquid save switch that ticks when your key lands.
Ambient weather card in the marketplace sidebar — one keyless IP geolocation + Open-Meteo, cached 30 minutes, degrading quietly.
Smoke behind the glass — the top bar carries a slow violet/cyan drift (WebGL fbm, low-power context) and a ~20% slimmer silhouette.
Previously in v1.1.0: the custom agent builder, race drafting, the neural layer, and ~20 hardening fixes.
Full history: docs/CHANGELOG.md.

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

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

enzo-projects — generated coding projects
enzo-skills — skills the agent learned from GitHub repos
enzo-memory — the agent's durable notes about your work

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:

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.
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.

AboutSelf-hosted AI workspace with agents, skills, and tools (Gmail, Calendar) that runs entirely on your own provider API keys (BYOK). Bring your own keys — Groq, OpenRouter, NVIDIA, Hugging Face, Google AI.enzo-hub.duckdns.orgTopicsaiai-agentsai-workspacebyokchatbotchatgpt-alternativedockergroqhomelabllmllm-agentsllm-chatbotmcpopen-sourceopenrouterproductiveself-hostedself-hosted-aiResourcesReadmeApache-2.0 licenseSecurity policySecurity policyActivityStars68 starsWatchers0 watchingForks15 forksReport repositoryReleasesPackagesUsed byContributorsLanguages

Footer

© 2026 GitHub, Inc.

Footer navigation

Terms

Privacy

Security

Status

Community

Docs

Contact

Manage cookies

Do not share my personal information

You can’t perform that action at this time.

ENZO is presented as a self-hosted artificial intelligence workspace designed to empower users by allowing them to operate entirely on their own provider API keys, embodying the Bring Your Own Key (BYOK) philosophy. The core concept is to provide developers and advanced users with access to agents, skills, and tools—such as integration with services like Gmail and Calendar—that run autonomously using keys from providers like Groq, OpenRouter, NVIDIA, Hugging Face, and Google AI, eliminating the need for an intermediary platform that charges fees or tracks usage.

The system is architected around a sophisticated agent-based workflow. It features a unified catalog of over three hundred models across nine providers, alongside bundled agent skills, and a two-pass system for self-drafting agents that derive operating manuals from plain-English tasks. This process involves a dynamic race mechanism where model responses are evaluated based on real-time performance, and a neural layer continuously refines the agent’s understanding by folding in domain-matched platform activity, allowing agents to improve themselves dynamically.

Security is a paramount concern in the design of ENZO. API keys are stored securely on the user's device, sealed using AES-256-GCM under a non-extractable key protected by the browser's vault mechanism. This client-side encryption ensures that keys are never stored on the server, addressing concerns about key exposure. Furthermore, the system incorporates rigorous security testing; every code push triggers a black-box pentest involving forty-four assertions against a booted server, checking for vulnerabilities like authentication bypass and hostile payloads. A critical security guarantee is the keyless boot proof, which mandates that the server must initiate with zero provider keys, ensuring that the system operates securely without relying on hardcoded credentials.

The deployment mechanism simplifies access considerably, relying on Docker Compose for setup across various operating systems. This structure ensures that the entire application, including all necessary services and agent memory, persists across restarts and upgrades, utilizing named Docker volumes for data storage. The design offers multiple interaction surfaces, including a terminal for streaming chat with models, a unified model marketplace, a keyless music player, and various research and code generation modes.

Recent updates, such as version 1.4.0, have introduced powerful new functionalities, including an in-chat file converter that allows for the parsing and extraction of data from various file types like PDFs and spreadsheets, enabling complex research tasks within the workspace. The system also supports deployment via Google Colab, which automates the cloning, building, and booting process, providing a secure, temporary environment for operation while maintaining the principle that all provider keys remain under the user's control. The development pipeline enforces strict standards, ensuring that no secrets are committed to repositories and that dependency audits actively fail builds if high or critical vulnerabilities are detected in the backend or frontend components. Overall, ENZO positions itself as an alternative to typical AI workspaces by prioritizing user sovereignty over data and keys, providing a transparent, highly secure, and self-improving platform for AI development.