Superlite cloud: a code factory that stays open when you close the laptop
A code factory turns a job into an approved plan, parallel work, inspection, and a branch. Superlite cloud puts that factory on a server your team controls.
TL;DR
- A code factory turns one request into a planned set of tasks, builds independent tasks in parallel, tests the seams, reviews the result, and hands back a git branch.
- Superlite is the open-source orchestration layer: the planner, parallel implementers, checkpoints, tests, reviewers, and tiered fix loop.
- Superlite cloud runs that factory on a shared server. Your laptop submits and steers the work; an isolated sandbox keeps building when your laptop closes.
- Every run starts with a plan, pauses once for approval, streams live events, and ends with
superlite/sessions/<name>on origin. If origin is unavailable, it returns a git bundle instead. - It is self-hosted, MIT-licensed, multi-agent, and bring-your-own-key. Today it supports Claude, Codex, Gemini, and Cursor.
- Use it when you want long-running agent work off your laptop, one operating model across a team, explicit ownership and handoff, and git—not a proprietary dashboard—as the final hand-back.
I already had the factory. It lived on my laptop.
The Superlite repository contains the factory itself. It takes a spec, gets a plan approved once, and puts agents on independent pieces at the same time. I wrote about how that feels in the introduction and how the machinery is bolted together in the tour of the gates.
The bench was gone. The building was still my computer.
Then the lid closes. Or the battery dies. Or the person who should take the branch is somebody else. A factory that only runs while you sit in the room is a bench with extra chairs.
Superlite cloud puts that factory on a server the team shares.
First: what is a code factory?
A coding agent is one skilled worker at one bench. Give it a job and it can inspect the repository, write code, run tests, and return a diff. The work can be excellent. It is still one track: decide, build, test, review. When the agent needs you, the whole track stops.
A code factory separates the stations:
- Intake. A job arrives in words: fix the login redirect, add an export, remove a flaky test.
- Planning. The job becomes a graph of pieces and dependencies. A person approves the plan once.
- The floor. Pieces that do not depend on one another are built at the same time.
- Inspection. Tests run, seams are checked, and a reviewer who did not write the code examines the result.
- The dock. The product leaves as a git branch. The transcript is the production log, not the product.
The branching is the important part. A factory does not make models type faster. It stops independent work from standing in line.
That requires more than launching many agents. The plan has to name stable interfaces. Finished pieces need checkpoints. Tests cannot block the coordinator. Review must be independent, and failed fixes need a way to escalate without dragging a giant conversation behind them. Superlite supplies those rules and gates.
This is also what separates a factory from a swarm.
A swarm is a count: ten agents are running. A factory is a production system: each worker has an owned task, inputs, outputs, and a definition of done. The coordinator knows which work is ready. A consumer can build against an agreed interface instead of waiting for its producer to finish. When both sides land, a seam check can answer whether the agreement held. A final reviewer receives a bounded packet instead of reconstructing the entire run from chat.
More agents without those contracts usually create more coordination. They edit the same files, repeat the same discovery, or produce individually plausible pieces that do not fit. The factory is not the fan-out. It is the task graph, the interfaces, the checkpoints, the inspection stations, and the rules about who may do what.
It is not an autonomous merge button, either. The output is deliberately a branch. The team still owns the decision to review and merge it. The factory automates production; it does not quietly redefine acceptance.
Superlite cloud does not replace that machinery. It moves the building.
What moves to the server
A local factory still has three bottlenecks, and none is the model:
- the laptop has to stay awake;
- the build occupies the session you wanted to use for something else;
- the run belongs to whoever started it.
Superlite cloud takes those three. It accepts work over REST or MCP, queues it, runs each job in its own sandbox, and streams the events back. Your local session becomes the window. The server does the build.
The workspace stores the provider keys for the agents it runs. Each job uses the CLI you chose—Claude, Codex, Gemini, or Cursor—and the corresponding key. The build's model calls happen in the sandbox, so your local Claude session spends no tokens performing that build.
The server is open source, MIT-licensed, and self-hosted with Docker Compose. This is deliberately not a second proprietary place where the code and the run history disappear.
The six pieces on the server
| Piece | Its job |
|---|---|
| Server | Authenticates the member, accepts tasks over REST or MCP, records run state, and serves status and live events. |
| Queue | Holds submitted work until a worker claims it. Submission does not require an open terminal to remain attached. |
| Worker | Prepares the checkout, starts and stops sandbox containers, pumps nudges into the selected agent, and performs the final git hand-back. |
| Repo cache | Keeps one full copy of each repository and fetches new commits. Runs use light clones that share those immutable git objects. |
| Sandbox | Owns one run's checkout and agent state. It receives one provider key and runs one selected agent CLI with Superlite. |
| Vault | Encrypts provider keys at rest with the server's master key and reveals only their final four characters in listings. |
Those pieces create three separate paths through the system:
- The control path is small: submit, inspect status, approve, nudge, cancel, or give the run to another member. REST and MCP expose the same run lifecycle.
- The event path is live but disposable. Plans, progress, notices, nudges, renames, and the final hand-back stream to watch. If the connection drops, the client reconnects from its last event rather than making the build restart.
- The code path is git. Source comes from the repository and finished work leaves as a branch or bundle. Large source trees do not travel through the chat protocol.
That separation matters. The chat session is a control surface, not the place where the checkout lives. The event stream is observability, not the source of truth for the code. Git remains the data plane.
What you actually do
Set up the server once, then log in from superlite:
superlite-cli cloud loginLogin looks for SUPERLITE_CLOUD_URL and SUPERLITE_CLOUD_TOKEN in a predictable order: explicit command-line values, the project's .env, then ~/.superlite/.env. It can also read the token from the clipboard. The token is never echoed back.
The token identifies a member, not merely a request. Reissuing a token for the same member preserves that person's runs and notices. That is why ownership, handoff, and “new run from Chris” can survive credential rotation.
After that, the interface is language:
| You say or type | What happens |
|---|---|
| “Run this in the cloud: fix the login redirect” | The job is submitted and gets a short name such as login_fix. |
approve |
The approved run continues building in its sandbox. |
>> run the tests first |
A nudge goes to the current run. Your local Claude never sees it. |
>>login_fix check the callback too |
The nudge goes to that named run. |
/superlite:runs [all] |
List local and cloud runs. Workspace admins can add all to see everyone's runs. |
/superlite:watch login_fix |
A live pane opens. A completed run replays from the beginning. |
/superlite:attach login_fix |
Every line you type goes to the run; prefix a line with \ to talk locally instead. |
/superlite:detach |
Leave attach mode without stopping the remote run. |
/superlite:give login_fix pat@example.com |
Transfer the run explicitly by email. |
| “Give login_fix to pat@example.com” | Pat becomes the owner while the run keeps going. |
A dropped watch connection reconnects and resumes. /superlite:detach leaves attach mode. The status line shows the run, agent, state, and step without making you keep a transcript in the foreground.
Watch and attach are deliberately different.
- Watch is the control room. It replays events, follows new ones, and has a small input line for nudges,
/approve, and/cancel. - Attach temporarily makes the remote run your terminal conversation. Normal lines go to the run; a line beginning with
\stays with your local agent. - The status line is the glanceable view. It lets you keep working locally while still seeing that
login_fixis running on step 14 with Claude.
You do not have to choose one permanently. Start from a sentence, watch when something interesting happens, attach when the run needs a conversation, and detach when it does not.
The complete feature map
The short pitch—send a task, watch it live, get a branch—hides a fair amount of product. Here is the public feature surface in the current 0.1 server.
Submit, control, and observe runs
| Feature | What it gives you |
|---|---|
| Natural-language submission | A connected local agent calls the remote submit_task MCP tool when you ask it to run work in the cloud. |
| REST submission | Scripts and integrations can create the same task with a repository, prompt, agent, and base ref. |
| Short run names | The server derives a readable one-to-three-word name such as login_fix; names work anywhere a task id works. |
| Plan-first execution | Every new task takes a planning turn and waits. approve or another response resumes the retained run. |
| Run listing | /superlite:runs combines your cloud and local runs. An admin can request every run in the workspace. |
| Status line and notices | Login enables a compact current-run display. Transfers create notices such as new: login_fix from chris. |
| Live watch | Server-sent events replay the run and then follow it live. The pane accepts nudges, /approve, and /cancel. |
| Attach and detach | Attach routes ordinary input directly to a run; \ escapes one line back to local Claude. Detach leaves the cloud job running. |
| Targeted nudges | >> text steers the current run and >>name text steers a named run. If the driver is between turns, the nudge queues for the next one. |
| Reconnect and replay | Streams carry event ids and keep-alives. A reconnect continues after the last seen event; a finished run can replay from event one. |
| Cancellation | The owner or an admin can stop a non-terminal run. The worker kills the active agent job and preserves cancelled as the final state. |
| Result lookup | MCP and REST expose the final task snapshot and the exact fetch command for its branch or recovery bundle. |
Calling /superlite:watch or /superlite:attach without choosing a run first can list the live choices, including state, current step, and agent. That keeps names discoverable rather than requiring a separate trip to a dashboard.
The MCP server exposes the same core actions as tools: submit, get, list, respond, cancel, fetch the result, give a run, read notices, and retrieve approved team lessons. REST adds health, event, nudge, bundle, account, learning, key, agent, and administration routes for clients that are not MCP hosts.
Members, accounts, roles, and handoff
| Feature | What it gives you |
|---|---|
| Workspaces | Runs, members, provider keys, webhooks, learning rows, and lessons are scoped to one team boundary. |
| Member identity | A member has a stable id, unique handle, email, and role. Replacing a token does not create a new person. |
| Member and admin roles | Members manage their work. Admins can see and control every run and administer shared resources. |
| One owner per run | Only the owner can watch, nudge, attach, approve, cancel, or give a run; admins can do so across the workspace. |
| Email-based transfer | Giving by email avoids transferring a live run to the wrong person with a similar handle. |
| Invites and browser sign-in | An admin can issue an invite; the member registers on the sign-in page and then manages personal access tokens. |
| Self-service tokens | Signed-in members can create, list, and revoke their own tokens. Token values are shown once and stored only as hashes. |
| Member administration | Admins can list members, rename handles, update emails, change roles, issue fresh invites, and lock access. |
| Live authorization | The server checks ownership and role on every request. Locking or removing a member also closes an already-open event stream. |
The browser is an account and setup surface, not a second run dashboard. The working interface remains the agent session, the watch pane, and git.
Agents and provider keys
| Feature | What it gives you |
|---|---|
| Four agent drivers | Claude, Codex, Gemini, and Cursor use one run contract while each driver speaks its own CLI protocol. |
| One choice per run | A task selects the agent it needs; different queued runs can use different agents. |
| Bring your own key | Anthropic, OpenAI, Gemini, and Cursor credentials belong to the workspace rather than a bundled model subscription. |
| Key verification | slcloud key set checks a key with its provider before storing it. A rejected key is not written to the vault. |
| Encrypted storage | Accepted keys are encrypted with SLCLOUD_MASTER_KEY, masked in output, and injected only into matching jobs. |
| Pinned worker tools | The worker image pins the agent CLIs and Superlite version so two team members do not get different factories because their laptops drifted. |
| Agent inspection | The authenticated setup page and API can list installed agents, show their versions, and check whether each CLI is available. |
| Generated connection commands | slcloud connect <agent> prints the exact configuration needed to connect that client to the remote MCP server. |
This is multi-agent, not multi-agent-within-one-task selection. One cloud run has one top-level CLI; Superlite inside that run performs its own coordinator, implementer, reviewer, and fixer orchestration.
Repository and hand-back features
| Feature | What it gives you |
|---|---|
| Any cloneable git repository | A task supplies a repository and base ref rather than depending on one forge-specific app installation. |
| Per-workspace repo cache | The server keeps full history once, fetches updates under a lock, and creates shared-object light clones for runs. |
| Base-ref validation | A base cannot masquerade as a command option or contain control characters; an unknown base fails instead of silently using another commit. |
| One checkout per run | Each sandbox gets its own writable worktree while the cache remains read-only. Parallel runs do not edit one another. |
| Stable run/session/branch naming | login_fix, login-fix, and superlite/sessions/login-fix identify the same work in the UI, Superlite, and git. |
| Collision-safe rename | The worker checks live names and origin branches again at hand-back. If the name was taken, it reserves and records a numbered replacement. |
| Secret-aware commit | Common environment, key, certificate, package-registry, and credential files are excluded from the final automatic commit. |
| Branch push | A successful run commits its checkout and pushes its session branch to origin. |
| Bundle fallback | If origin cannot accept the push, the server creates a git bundle and returns an authenticated download and fetch command. |
| Internal Superlite checkpoints | Hidden refs/superlite/* preserve task output during the build while the human-facing hand-back remains one session branch. |
Events, APIs, webhooks, and learning
| Feature | What it gives you |
|---|---|
| Structured run events | Plans, status changes, agent output, nudges, notices, renames, results, and hand-back information have ordered event ids. |
| Resumable SSE | REST clients can send Last-Event-ID or an after cursor and receive only later events, with keep-alives during quiet periods. |
| REST and MCP | Human-facing agents use MCP; automation and custom clients can use the REST API without inventing a second task model. |
| Signed webhooks | Registered workspace webhooks receive a task snapshot signed with HMAC-SHA256 in X-Slcloud-Signature. A failing webhook never fails the run. |
| Incremental learning sync | slcloud sync reads the local allow-listed outbox after its saved byte offset and advances only after the server accepts the rows. |
| Idempotent ingestion | Learning row ids deduplicate retries, so a repeated sync does not double-count the evidence. |
| Signal totals | The workspace can aggregate accepted rows by signal without turning raw transcripts into shared instructions. |
| Reviewed team lessons | Members propose lessons into a held state; admins approve or withdraw them; agents retrieve approved lessons only. |
Operations and deployment
| Feature | What it gives you |
|---|---|
| Docker Compose deployment | The default stack separates the HTTP server from the privileged worker that starts run containers. |
| Direct process commands | slcloud serve and slcloud worker can run the two services without Compose when another supervisor owns the processes. |
| Docker or Podman | The worker's container CLI is configurable, including the standard Docker client environment needed for a remote or Podman socket. |
| Container or process sandbox | Docker is the production default. Process mode exists for controlled development environments where container isolation is intentionally disabled. |
| Optional gVisor | SLCLOUD_GVISOR=1 adds runsc as the sandbox runtime when it is installed on the host. |
| Resource limits | Run containers have CPU, memory, process-count, capability, privilege-escalation, and execution-time limits. |
| Optional HTTPS | The Compose profile includes Caddy; SLCLOUD_DOMAIN supplies the public hostname. |
| Health endpoint | Operators and container health checks can verify that the server is responding without authenticating a task request. |
| Backup and restore | The CLI copies the SQLite database to a backup file and restores it. Restore refuses to run while the server or worker holds the database. |
| Configurable storage and image | Operators can move the shared work root and select a pinned worker image without changing application code. |
One run, end to end
Suppose the job is “fix the login redirect.”
The server names it login_fix. Superlite's session slug is login-fix. Its branch is superlite/sessions/login-fix. Those are three views of the same run: a short name for people, a slug for the session, and a branch for git.
The run then moves through a small state machine:
| State | Meaning |
|---|---|
| queued | The server accepted the task; a worker has not claimed it yet. |
| running | The sandbox is alive and the selected agent is planning or building. |
| waiting | The first turn produced a plan. The checkout and agent state are retained while the server waits for approval. |
| running again | Approval or another response resumed the same run in the same working directory. |
| done | The branch was committed and handed back through origin, or a recovery bundle was produced. |
| failed / cancelled | The run stopped. Errors are masked for stored secrets; cancellation prevents the worker from changing the terminal state afterward. |
Under that sequence, the mechanics are deliberately boring.
The workspace keeps one full copy of each repository. A run fetches only new commits and makes a light clone with shared git objects. A repo the server has already seen can be ready in seconds without copying its whole history again.
The agent starts by producing a plan. The run moves to waiting; its checkout and agent state stay in place. Approval resumes that run rather than starting over.
While it runs, events stream out. Watch shows them. Attach sends your lines directly to the run. A nudge is queued for the agent's next turn if it cannot be delivered immediately. Cancel stops the job.
At the end, the server commits the work and pushes the session branch. Common secret files—.env, private keys, credential files, .npmrc, .netrc, and similar names—are excluded from that commit.
If origin already has the branch while the run is live, the run takes the next free name, such as login_fix_2, and renames its superlite session before pushing. It does not overwrite somebody else's branch.
If the push fails, the work is not thrown away. The server creates a git bundle and returns the command that fetches it.
Why the plan is still a gate
Putting work in the cloud should not mean putting the first interpretation of a prompt beyond reach.
The planning turn is intentionally separate from the build turn. The sandbox inspects the repository and returns a concrete plan. The run then waits. Approval is not a new job: it is the input that resumes the existing checkout and agent session.
That gives the person one high-leverage decision before the expensive fan-out begins. Is the scope right? Are the named interfaces sensible? Is it touching the correct package? After that, Superlite's normal promise applies: ready work starts without another trail of “may I continue?” questions.
If you want less steering, the orchestration mode can delegate more of those decisions. The important part is that the boundary is explicit rather than accidental.
The factory inside the sandbox
The cloud does not invent a second build process. Inside each sandbox is superlite:
The coordinator decides and dispatches. It does not write product code. Implementers receive separate tasks and work side by side. Tests run in the background. When both sides of an interface are present, scripts check the seam.
The final reviewer is fresh and read-only. It returns findings rather than quietly fixing its own homework. Fixes are routed by how much is known: local and understood, cross-module but understood, or unknown and requiring diagnosis. Two failed rounds at a tier escalate to the next one. A short fix note carries the evidence forward instead of an enormous old conversation.
During a run, finished tasks live on hidden refs/superlite/* checkpoints. The branch people review is created at the dock.
Planning for parallel work
The plan is not a prose checklist. It is a task graph. Each task names what it owns, what it depends on, and what it produces or consumes. Stable tasks can begin while the coordinator repairs an unrelated weak part of the plan. Consumers work against interface stubs and examples, then a seam check compares the real producer and consumer once both are checkpointed.
That is how parallelism avoids becoming a merge race. Ownership limits where each implementer writes. Contracts let work begin before every dependency is physically present. Checkpoints make completed task output durable without turning every internal step into a branch commit.
Giving agents enough context, but not all context
Every fresh implementer receives a small, stable prime: its rules, the plan header, global constraints, and the titles and interfaces of stable tasks. It then reads its own current task text. The whole changing plan is not copied into every agent.
This is both a correctness and a cost decision. A large shared prompt gets stale while the coordinator fixes the plan, and every distinct prefix can create another prompt-cache write. A byte-identical slim prime is more likely to be reused; fetching the task afterward keeps the assignment current.
Inspection is a different job
Tests answer objective questions. Seam checks answer whether adjacent tasks honored their declared contract. Package review looks at a coherent area. The final reviewer gets a fresh review packet containing the test summary, incidents, probe failures, and relevant source excerpts.
That final reviewer reports findings only. It cannot normalize its own implementation choices while judging them, because it did not implement the code and cannot edit it. Fix-only agents receive the findings by tier. If a tier fails twice, the next tier starts fresh from a compact note describing the goal, evidence, attempts, and best remaining hypothesis.
The point is not ceremony. It is to keep implementation, judgment, and diagnosis from collapsing into one long self-justifying conversation.
For the detailed version—including the gates, the task primes, and which ideas failed when measured—read Inside superlite. For the speed argument, the benchmark shows why parallel model work beats the same work arranged in a line.
Why a team would use it
Use superlite cloud when the factory is already how you want the work done, and the laptop is the part that does not scale.
The run is longer than your battery
The sandbox keeps the checkout and agent state. Close the laptop. Reconnect later. If the run has finished, watch can replay it.
You want your local session back
Submitting a run is not the same as donating the conversation to it. Your local agent can move on while the server's selected agent builds.
The starter and finisher are different people
Every run has one owner. That owner can watch, nudge, attach, approve, cancel, or give it away. Giving by email avoids ambiguous handles. The run stays in place; ownership moves.
Pat's status line can say new: login_fix from chris. A new token for Pat still maps to Pat and the same runs; identity does not live in the token string.
The team needs one floor, not many private workbenches
Members have individual tokens. Admins can inspect all workspace runs. Local superlite learning rows can sync to the server incrementally; duplicate rows are ignored.
Shared lessons are reviewed rather than injected automatically. A member proposes a lesson, it stays held, and an admin approves or withdraws it. Only approved lessons are returned to the team. That is an important boundary: an agent's observation does not become everybody's instruction merely because it was written down.
The rows sent by slcloud sync are incremental and idempotent. The client keeps an offset, so the next sync sends only newly appended rows; the server ignores duplicates by row id. The shared store can count signals and support proposed lessons without copying an entire raw run transcript into a team prompt.
This is a conservative learning loop. Run evidence can suggest a lesson. A person still decides whether that lesson deserves to influence everyone else's future runs. Shared memory without review is another name for a prompt-injection distribution system.
You want agent choice without changing the production line
Claude, Codex, Gemini, and Cursor are separate drivers behind the same run lifecycle. You choose one per task and bring the provider key. Planning, ownership, events, branches, and hand-back remain the same.
You want the output to remain git
The result is not trapped in a dashboard. It is a normal branch on origin, or a portable git bundle when origin is unavailable. Review it, rebase it, merge it, or throw it away with the tools the team already uses.
When it is the wrong tool
Not every change needs a factory.
For a one-line rename, a local agent is faster than submitting, planning, approving, and handing back a cloud run. For a task that depends on hardware attached to your laptop, a private network the server cannot reach, or a large local unpushed state, the remote sandbox does not magically have those things. Push the needed base first or keep the job local.
It is also the wrong tool if “self-hosted” is being used to mean “safe without administration.” The worker is privileged infrastructure. Provider keys need a real master key. Public access needs HTTPS and network controls. Backups need to exist before restore day.
And a completed branch is not proof that the product decision was right. The factory can enforce a build lifecycle, run tests, and make review independent. It cannot supply missing acceptance criteria or decide that a risky product change should ship. It makes the engineering process repeatable; it does not remove engineering ownership.
The security boundary
Self-hosted does not mean harmless. The worker mounts the Docker socket because it starts sandbox containers. Docker-socket access is effectively root on the host. Treat the worker as privileged. The run sandboxes never receive that socket.
A sandbox gets its own working directory, the repo cache read-only, and one provider key. Capabilities are dropped, new privileges are disabled, and CPU, memory, process, and time limits are set. Agent session state is stored beside the checkout, not inside it, so it cannot be committed and the agent cannot redirect it with a symlink.
Sandboxes do have network access. They can reach anything the worker's network can reach. Run the server on a network you trust for that. If runsc is installed, SLCLOUD_GVISOR=1 runs sandboxes under gVisor for a stronger syscall boundary.
Provider keys are encrypted at rest with SLCLOUD_MASTER_KEY; listings reveal only the last four characters. Workspace tokens are shown once and stored as hashes. Keys are redacted from events, logs, errors, and API output. Lose the master key and the provider keys cannot be recovered—you set them again.
Claude runs with --bare, which skips project hooks, plugin sync, and automatic project-configuration discovery. The run uses what slcloud explicitly supplied rather than executing a repository's startup hooks.
Read the repository's security model before exposing a server publicly. Put it behind HTTPS, issue one member token per person, and restrict who can reach it.
Standing it up
The README has the current commands. The shape is:
- Generate a high-entropy
SLCLOUD_MASTER_KEY. - Run
docker compose up -d --build. - Run
slcloud initinside the server container to create a workspace, admin token, and invite. - Store provider keys with
slcloud key set; it reads from stdin so the secret stays out of shell history. - Add members or let them register with invite codes.
- Run
slcloud connect claude,codex,gemini, orcursorfor each client you use. - Log in locally and send the first task.
In commands, the server side starts like this:
cp .env.example .env
# Set SLCLOUD_MASTER_KEY to the output of:
openssl rand -hex 32
docker compose up -d --build
docker compose exec server slcloud initslcloud init prints the workspace's first admin token and invite. Both are credentials; the token is shown once. After pointing the CLI at the server, store a provider key and connect a client:
export SLCLOUD_URL=https://cloud.example.com
export SLCLOUD_TOKEN=slc_...
slcloud key set anthropic
slcloud connect claudeslcloud key set reads the secret from stdin rather than placing it in shell history. slcloud connect prints the configuration command for the selected client. Repeat it for the clients the team actually uses, not every driver merely because it exists.
For a team, issue a separate token for each member or give them an invite for the sign-in page. Use the member role unless someone needs to administer the workspace. One shared admin token removes the ownership and audit boundary the member model is meant to provide.
The complete environment configuration is small:
| Setting | Default | Purpose |
|---|---|---|
SLCLOUD_MASTER_KEY |
required | Encrypt stored provider keys. It should be the high-entropy output of openssl rand -hex 32. |
SLCLOUD_URL |
http://localhost:8787 |
Public base URL used by agents, browsers, generated connection commands, and bundle links. |
SLCLOUD_DOMAIN |
empty | Hostname for the optional Caddy HTTPS profile. |
SLCLOUD_WORK |
/srv/slcloud/work |
Shared task-work root; the host and worker must see it at the same path. |
SLCLOUD_SANDBOX |
docker |
Select docker for containers or process for an intentionally uncontained development run. |
SLCLOUD_GVISOR |
0 |
Set to 1 to add the gVisor runsc runtime. |
SLCLOUD_DOCKER_BIN |
docker |
Select the container CLI, normally docker or podman. |
SLCLOUD_WORKER_IMAGE |
slcloud-worker:0.1.0 |
Image containing the pinned agent CLIs and Superlite installation. |
Provider keys do not belong in this file. They go through slcloud key set, are tested, encrypted, and stored in the workspace vault.
slcloud sync sends only new learning rows. slcloud backup and slcloud restore move the database. Docker is the default; Podman works by pointing SLCLOUD_DOCKER_BIN and DOCKER_HOST at its socket. The repository includes a Caddy configuration for the optional HTTPS front.
The smallest useful deployment is one server and one worker. That is the self-hosted small-team target, not a claim that a single Docker host is a multi-tenant security platform. The architecture can grow later; the first goal is a factory a team can understand, operate, back up, and leave running.
The short version
A code factory takes a job in words, freezes a plan with one approval, builds independent pieces together, inspects the result with tests and a reviewer, and ships a branch.
Superlite is that factory. Superlite cloud is the factory on a server your team runs: a queue, a sandbox per run, a shared repo cache, a window on your laptop, and a branch on origin when the run is done.
You use it when the work should keep going after you stand up, and when the person who finishes the run does not have to be the person who started it.