// REAL-WORLD CAPABILITY LAYER FOR AI AGENTS

Your agent has
the brains.
Clize gives it
hands.

■ HANDS — real-world capability ■ CONTINUITY — pick up where you left off

In Claude Code or Codex, just say the word — Clize buys the domain, generates and ships the site, sets up a real inbox it can send and receive from. The things your agent can't do alone, done.

> Your agent is the brain; we're its hands, identity, and continuity.

[ See what it can do → ] [ Install in 60s ↓ ]

WHAT · WHAT YOUR AGENT GETS DONE

SAY IT IN PLAIN ENGLISH.
YOUR AGENT MAKES IT REAL.

= hands · identity · continuity

// HANDS — real-world capability

+--- SHIP A SITE ---+ [HANDS]

Your agent designs to one coherent style first — chosen from a curated library, not AI-template sludge — then ships. Domain, DNS and HTTPS handled automatically.

You say: "Make me a consulting site with real taste." 
$ clize build site start "consulting site"  # cohesive style + method
$ clize serve ./site  # preview locally first
$ clize deploy ./site --domain mysite.com
+--- SEND & RECEIVE EMAIL ---+ [HANDS]

Real support@ inboxes that actually send and receive — your agent can be reached, and can reply.

You say: "Give my agent its own inbox." 
$ clize claim acme  # acme.clize.app + support@ · sends & receives
+--- CLEAR ITS OWN GATES ---+ [HANDS]

Hit a "verify your email"? Your agent reads the code from its own inbox and self-registers for the service.

You say: "Go sign me up for that API." 
$ clize email inbox mysite.com
+--- WIRE UP A WORKFLOW ---+ [FEATURED]

Support / onboarding / quoting — give the inbox a role: tag it and feed it your docs, so your agent answers in scope.

You say: "Set me up customer support." 
$ clize email address add [email protected] --tag support --knowledge ./docs
+--- GET PAID ---+ [HANDS]

Your agent sends a customer a real payment link — money lands in your own Stripe, or in your Clize balance. The quoting desk finally closes the loop.

You say: "Bill this client $400 for the logo." 
$ clize pay link --amount 400 --for "logo design"
+--- GENERATE MEDIA ---+ [HANDS]

Your agent writes the prompt; Clize generates the bytes to disk — images, video and music with no model keys of your own (Clize pays the providers: gpt-image-2 · nano-banana-2 · veo · suno). Spend-gated; results land as files, ready to deploy or attach.

You say: "Make a logo for the site." 
$ clize gen image "minimalist logo, deep green" --confirm
$ clize gen video "logo reveal, 4s" --confirm
$ clize gen music "calm lo-fi intro" --confirm
+--- PRODUCE A CLIP ---+ [HANDS]

Your agent writes a shot-by-shot blueprint; Clize lints it for continuity, then batch-generates every shot and stitches the final cut — one summed quote, resumable.

You say: "Make a 20s promo clip." 
$ clize build clip start "20s promo"  # shot blueprint
$ clize build clip render --confirm  # batch + stitch
+--- RUN MANY AT ONCE ---+ [HANDS]

One agent, many projects — each site, inbox and domain in its own clean workspace. Switch with a flag; spend and status roll up per project.

You say: "Spin up a second client, keep it separate." 
$ clize projects new acme --use
$ clize status -p acme

// CONTINUITY — pick up where you left off

+--- PICK UP ACROSS SESSIONS ---+ [CONTINUITY]

Every new session starts cold. Clize hands the thread back: who you talked to, where it left off — so you're never re-explaining from scratch.

You say: "Where did we leave off with this customer?"

// session handoff

# new session starts
session: cold start

▲ clize context
  [OK] thread restored
  · last_contact: Alice (3h ago)
  · status: awaiting proposal
  · next: follow-up email

$
= hands · identity · continuity

The three things an agent lacks in the real world — we supply all three at once.

HOW · INSTALL · HOW IT WORKS

ONE PASTE TO SET UP.
THEN JUST TALK.

Paste one prompt into Claude Code or Codex — your agent installs clize and signs itself in. Or wire the CLI by hand.

clize — paste into Claude Code or Codex
01 PASTE & GO — your agent installs its own hands; you just answer a prompt or two. 
Set up clize as your own tools, so you can register domains, run real email, and ship live websites for me.

  1. Install:  npm i -g @clize/clize
  2. Run clize install — it adds the clize skill so you'll know to use these tools on your own next time.
  3. Run clize login — it opens GitHub in the browser to authorize; the first login also creates my account. Walk me through it.
  4. Run clize check and confirm you're connected.

Then tell me you're ready — and always ask before spending money or emailing a real person.
02 · OR WIRE IT YOURSELF — CLI 
$ npm i -g @clize/clize
$ clize install    # wire into Claude Code / Codex
$ clize login      # GitHub sign-in in your browser
$ clize check      # ✓ connected

clize install drops the clize skill into Claude Code / Codex so your agent reaches for clize on its own; clize login opens GitHub to authorize (creates your account on first run). Self-host / CI: clize login --token <key>. The CLI is the whole interface — MCP is optional (clize install --mcp).

03 · THEN JUST TALK 
> Build me a consulting site,
  put it live, and add a
  support inbox.

Your agent runs the clize commands one by one; you just sign off. Every spend and every send shows up in plain text first.

two ways to run

■ HOSTED — recommended

clize login with GitHub and go — your agent never touches Cloudflare. Domains, email, deploy, media and the design system all run on clize's infra — on a free handle, a domain you buy, or one you already own elsewhere (just point its nameservers, no key).

A prepaid balance covers domains & hosted media — top up with clize recharge, track it with clize balance / clize audit.

■ SELF-HOST — bring your own Cloudflare

clize login --token <CF> — commands run locally against your own Cloudflare account. No clize balance; spend goes straight to your provider.

Same domains / email / deploy, just on your own account & billing, with bring-your-own model keys for media. Nothing here hosted can't do — it's for folks who'd rather own the infra.

+--- HOW IT WORKS — "SET UP SUPPORT", IN THREE MOVES ---+ 
$ clize email setup growthlab.com
$ clize email inbox-setup [email protected]
$ clize email address add [email protected] --tag support --knowledge ./docs

01 PROVISION

the support@ inbox

Address provisioned, DNS wired, inbound + outbound live.

02 TAG / SCOPE

role & boundaries

Tag defines the scenario; scope limits what the agent can act on.

03 FEED KNOWLEDGE

reads your docs

Docs loaded. Agent knows product context before first reply.

// BRAINS vs. HANDS

Reading the email, judging it, drafting the reply — that's Claude Code's brain. Provisioning, wiring the scenario, carrying context across sessions, real send & receive — that's our hands + scaffolding + continuity. Need to touch payments or a backend? Your agent calls the tools you wired; we don't think for it.

You don't start from a blank page — the built-in site-build skill generates a real site (consulting / SaaS / portfolio); deploy ships it.

WHY · WHY WE BUILT THIS

AGENTS ARE CAPABLE —
BUT TRAPPED IN A SANDBOX.

AI now lets one person build a product — but their agent can't reach the real world (no domain, no inbox it can send & receive from, no way to ship a site), and it forgets everything every new session. Clize fills exactly those two gaps: real-world hands, plus continuity across sessions.

+--- SMOOTHER EVERY TIME ---+
CONTINUITY

Auto-resumes the thread, so you're never re-explaining who you talked to or where it stands.

context restore [||||||||||] 100%

+--- RUNTIME-NEUTRAL ---+
PORTABILITY

Claude Code, Codex, whatever's next — your identity and context come along.

runtime switch [||||||||||] seamless

+--- SECURE BY DEFAULT ---+
TRUST

Inbound is always untrusted, never treated as instructions; credentials are encrypted and never enter the context window.

inbound trust [░░░░░░░░░░] sandboxed

clize init — ready

GIVE YOUR AGENT A PAIR OF
REAL-WORLD HANDS.

CLI-first — plug-and-play in Claude Code and Codex. Start with support.

[ Get started → ] [ npm ]

$ clize login --token