Starko

A full dev environment per run,with the app running where you can see it.

Each Starko AI run and session works in its own isolated cloud sandbox with your repository checked out, your services running and a real browser. Starko prepares that environment itself, asks you only for the secrets it cannot know, and destroys the sandbox when the run ends.

At a glance

Cloud sandboxes in short.

One sandbox per run
Every fix run, session and setup run gets its own. None is shared, and none outlives its run.
Machine
4 vCPU, 8 GB memory and 10 GB disk.
Toolchain
Node 24 with npm, pnpm and yarn, Docker with Compose, Playwright with Chromium, and the GitHub CLI.
Setup
Set up the sandbox takes about four minutes and saves the commands it chose to the project.
Secrets
Stored encrypted and injected at launch. The agent is told the names, never the values.
Warm snapshot
Runs boot with dependencies installed. Rebuilt when setup or a dependency file changes, and after a week.
Preview
A signed link to the app's port inside the sandbox, valid for an hour and dead when the run ends.
Hard stop
Fix runs stop after about 45 minutes, sessions after 2 hours. Each sandbox also deletes itself on its own timer.
Set up the sandbox

Starko sets up its own sandbox, and asks you only for what it cannot derive.

From a project with a linked repository, Set up the sandbox starts a live Starko AI session whose only job is the environment. It reads the package manager, scripts and Compose services from the repository, asks for the secrets the manifests name that only you can give, then installs, starts the backend and the app, and proves it works with a screenshot. It stops only on what it cannot solve, and tells you exactly which values are missing.
  • Install: dependencies with the project's own package manager.
  • Backend: Compose services and databases, if the app needs them. Docker and Compose are built into the sandbox.
  • Start the app: in the background, until its URL answers.
  • Prove it with a screenshot: opens the app with the preview login and captures the page a user sees.
  • Tests: a quick test run, when the project has one. Then the commands and URL are saved to the project and a warm snapshot is built.
  • Prefer to do it yourself? Fill in by hand, and every line stays editable in the project's Starko AI settings.
Environment

Everything the agent runs with, on one tab per project.

A project's Starko AI settings have an Environment tab with six rows: Install, Backend, App, Secrets, Preview login and Tests. Each row shows what is set and whether it is ready, and the header says whether Starko has proven the app runs. Changes apply to the next run. Variables also reach sessions that are already running.
  • Sandbox environment variables are entered as KEY=value or by importing a .env file. They are stored encrypted, never shown again and never placed in a prompt.
  • Preview login: paste a Cookie header, a cookie export or a Playwright storage state, so screenshots and the agent's own checks see the signed-in app instead of the login form.
  • Without an app command and URL, screenshots and browser checks are off. Without a test command, Starko cannot run its own check after the agent.
  • Editing the environment needs an owner or admin.
Warm sandbox

Runs boot from a snapshot with dependencies already installed.

After setup, Starko keeps a snapshot of the repository with its dependencies installed. A run boots from it, fetches the latest commits and re-runs setup only when a dependency manifest changed: lockfiles, package.json, requirements, a Dockerfile. Without a snapshot, every run installs from scratch.
  • The snapshot rebuilds on its own when the setup command or a dependency file on the default branch changes, and after a week.
  • If a re-run of setup takes longer than four minutes, the run falls back to a fresh install instead of hanging.
  • Prepare sandbox and Rebuild are on the Environment tab, with the commit the snapshot was built from.
  • The ledger on Settings, Starko AI shows median run duration for warm and cold starts side by side.
Learn project

A map of the repository, written before the agent changes anything.

Learn project sends Starko AI to research the repository in a sandbox and write a repo map: Overview, Directory layout, Commands, Conventions, Where things live and Gotchas. Every later run gets the summary in its prompt and the full map as files it reads when it needs them, so it does not spend the first minutes of each run rediscovering your codebase.
  • The summary is one paragraph, up to 1,500 characters. Sections are markdown that cite file paths.
  • Edit any section yourself. Saving creates a new version; rules for the agent belong in the agent instructions instead.
  • Each version records the commit it was learned from. A map more than a month old suggests a refresh.
  • Research runs and setup runs do not get your team's skills, so the map describes the repository and nothing else.
Preview and console

Open the running app and a shared terminal while the agent works.

While a run or session is live, the ticket's Starko AI workspace can show a Preview of the app running inside the sandbox, and a Console into the same machine. Click through the fix yourself before the pull request even exists, run the tests, or check something by hand on the same machine.
  • The preview uses the project's App URL, or port 3000 when none is set. If nothing listens yet, it says so and retries on its own.
  • Preview links are signed, expire after an hour and stop working when the sandbox is destroyed.
  • The console has Run project and Run tests buttons from the project's commands. The working directory persists between commands, and Ctrl+C stops the running one.
  • The console is shared with everyone on the ticket. Every command, who ran it and its output are recorded on the run.
  • Neither the console nor steering extends a run's time limit.
Limits and cleanup

Every sandbox has a hard stop, and none outlives its run.

A fix run is interrupted after about 45 minutes, and a session after 2 hours or 15 minutes without a message. When the limit is reached the agent stops and the sandbox is destroyed, whatever is happening in it. Before that, Starko collects the evidence: commands, screenshots and its own run of your test command, which feed the review and merge step.
  • Each sandbox also carries its own auto-delete timer, so it dies even if the run that started it does not finish cleanly.
  • A sweeper finalizes runs that stall, so no sandbox is left waiting on a run that will never report back.
  • The GitHub token inside is scoped to the one repository, with contents and pull request access, and refreshed before it expires. Tokens are scrubbed from transcripts before they are shown or stored.
  • Evidence files live outside the repository checkout, so nothing the agent collects ends up in a commit.
  • Continue session boots a new sandbox on the same branch with the earlier conversation as context.

FAQAbout Cloud sandboxes.

Keep exploring

Connect a channel and a repository. Turn the support queue into a build queue.

Feedback starts flowing in minutes. The first recommendation shows up as soon as a pattern repeats, and the first pull request as soon as you accept one.

Start for freeGet a demo