Kalokoby

Kaloko is where teams review what their AI agents built.

See what your agent built overnight.

Like the nightly build, only with screens: whatever your agents designed and built overnight is on one canvas in the morning, in every language and on every device. Go through it over coffee, comment, approve.

Free plan, free for good · e-mail sign-in · the first run in ten minutes

Livetoday 05:25 CET11 of 12 passed11/12 stepsOpen the whole run ↗

This is not a mock-up. Kaloko walks its own public pages every day and the canvas above is that run. When something fails, the label says so and it is fixed in the next release.

Contact sheet of the run

Real screenshots from the run above. The stamp on each one says whether the step passed its checks, a person sent it back, or someone still has to decide.

  • Screenshot of the step “Landing page”, EN, desktopOK
    Landing pageEN · desktop
  • Screenshot of the step “Install tabs on the homepage”, EN, desktopOK
    Install tabs on the homepageEN · desktop
  • Screenshot of the step “Create an organization”, EN, desktopOK
    Create an organizationEN · desktop
  • Screenshot of the step “Sign in”, EN, desktopOK
    Sign inEN · desktop
  • Screenshot of the step “Guides”, EN, desktopOK
    GuidesEN · desktop
  • Screenshot of the step “Claude Code guide”, EN, desktopOK
    Claude Code guideEN · desktop
  • Screenshot of the step “Page not found”, EN, desktopOK
    Page not foundEN · desktop
  • Screenshot of the step “Pricing”, EN, desktopOK
    PricingEN · desktop

Waiting for a person· 19 Nov 2026· 40 screens· EN, CS

  • OK passed or approved by a person
  • Returned a person sent it back with a note
  • Failed a check failed
  • ? a person decides

We know this from our own projects

  • The agent finishes a task overnight, the PR is merged by morning, and nobody has seen what it looks like.
  • The English version has been checked; nobody has opened the German one or the phone layout yet.
  • The client asks what changed since last week, and the answer is spread across five threads.
  • Three agents pushed three branches to staging and nobody knows which one is which.

One loop, six steps

Kaloko starts at the first screen, long before the test at the end. Agents do the work at every step and people make the calls.

  1. Design

    Design the screens of a flow with your agent as live HTML on your tokens; the team comments in real time.

  2. Build

    The agent you already use writes the code: Claude Code, Codex, Cursor or a person. Kaloko prescribes none of them.

  3. Walk

    An agent or a Playwright script walks the acceptance plan and captures every screen and e-mail, on desktop and mobile, in every language.

  4. Assess

    What can be counted is checked deterministically, with evidence. Criteria that need judgement go to an AI evaluator: ours, hosted, or your own key.

  5. Decide

    People approve a step, return it with a note or decide a disputed criterion. Every stamp carries a name.

  6. Fix

    The agent reads the notes, fixes them, answers each comment and walks the affected steps again.

Three stamps; a person settles each one

approved

A person looked and agreed.

returned

A person looked and wrote what to change.

needs a human

The evaluator was not sure. Someone decides on the canvas.

What the canvas shows

  • Screenshots of every step on desktop, phones and tablets, in Chromium, WebKit and Firefox, light and dark; e-mails and third-party screens too
  • Pass, partial or fail per criterion, per locale and viewport, with the evidence and a one-sentence reason
  • Page metadata: title, description, canonical, hreflang, Open Graph, JSON-LD
  • Branch, commit, author, PR and environment; a pixel diff, swipe or onion skin against the accepted run
  • Review mode: only the steps that need a decision, one key per verdict; approvals carry over steps that did not change
  • A recording and a trace of each step: clicks, requests and console
  • Replay: step by step with a choice at every decision, for people who do not read canvases
  • Links to a specific step and criterion you can send to colleagues

Independent of host, agent and AI vendor

The big platforms keep review inside their own product. Kaloko sits above them, so the team reviews and signs off in one place, whoever hosted the build, wrote it or judged it.

Any host, or none

Local, staging behind a sign-in, production read-only, mobile and desktop apps, e-mail inboxes. No tie to one hosting provider or its preview URLs.

Any coding agent

Claude Code and Codex use the skill, Cursor finds it through the AGENTS.md that kaloko init --agent codex writes, and any agent can use the MCP server; a person can walk by hand. Every write carries the agent’s name.

Any AI for judgement

Deterministic checks first. The semantic evaluator is replaceable: hosted by us or with your own key. Each verdict keeps who or what decided.

Several agents, one overview

Projects, issues, scenarios and runs in one place: who is looking, who changed what, and comments an agent picks up and answers.

Your data stays yours and readable on every plan, also through the API. From Team, a run downloads as a ZIP and agents read it over MCP.

Situations we handle

Each page states the problem in one sentence, gives you one prompt for your agent and shows what comes out.

All situations and guides →Comparisons: Kaloko vs Percy and Chromatic · vs manual QA · vs Loom and screenshots

Fits the tools you already use

  • Claude Code, Codex and Cursora skill that knows when and how to walk, capture, evaluate and share; Cursor reads it through the AGENTS.md that kaloko init --agent codex writes
  • GitHub and GitLabkaloko ci github or gitlab writes a workflow that walks what a pull request changed on its preview and comments the link; the GitHub App adds a Kaloko check you can require before the merge, also when your agents work in the cloud (guide)
  • Figmakaloko design import figma turns frames into design steps and variables into tokens
  • Jira and Linearan issue from a returned step, with the screenshot and the criterion; when it is done, the comment on the step is resolved
  • Slack, Teams and e-maila channel per project for new runs, returns and approvals; a digest of what needs you
  • Mobile and desktop appsAndroid, the iOS Simulator and real iPhones, Electron, macOS and Windows apps on the same canvas; screens from Maestro, Appium or XCUITest imported with their UI tree (guide)
  • MCPruns, feedback, verdicts and the inbox over MCP at kaloko.app/mcp
  • Scheduleson Business, Kaloko’s own browsers open your pages every day or week, without a CLI

For designers: the design every implementation is checked against

Design the screens of a flow as live HTML with your own agent and skills, with your team watching in real time. Once you accept a version, every implementation run is checked against it: pixels, structure, tokens and contrast.

Draft, live and shared

Your agent writes each step as live HTML; the team clicks through the prototype, pins comments on elements and sees each other’s cursors.

Versions without duplicates

Publishing makes a version of the whole flow. Unchanged steps are stored and rendered once; compare shows only what moved.

Design reference

An accepted version becomes the reference. Developers’ agents take the live files and tokens from it, step by step.

Checked implementation

The design pack compares every implementation run with the reference and names the token to use where it drifts.

How to design with your agent in Kaloko →

After the sign-off

Accepted runs keep working once the release is out: they are the pictures in your changelog and help pages, and the proof of who approved what.

A changelog with pictures

kaloko release records a version with its CHANGELOG entry and pictures from accepted runs. On Business the changelog can also be a public page with a feed.

Docs that keep up with the app

Markdown in docs/ points at steps instead of pasted screenshots, so readers see today’s screens. On Business, Kaloko marks the sections whose screen changed and exports to Docusaurus, VitePress, MkDocs or PDF.

Every screen in one library

The newest screenshot of every step across your flows, searchable by title, text or URL, with a link back to the canvas.

A signed acceptance record

On Business, an accepted run gives a JSON and PDF record of who approved what and when, signed by Kaloko; kaloko signoff --verify checks it without an account.

How the changelog and docs work →

See it on Kaloko itself

We keep our own changelog and help this way. Both are public:

Install once, then work through your agent

Kaloko runs where your code and your agent are. The service stores and versions the results, shows the canvas and collects approvals.

  1. Add the CLI to the project
    npm install --save-dev kaloko

    Needs Node 20 or newer. Update later with npm update kaloko.

  2. Create the config and install the skill
    npx kaloko init --agent claude --org <your-org>

    The skill is copied to .claude/skills/kaloko. npx kaloko doctor checks Chrome, the config and the token.

  3. Create your organization and a token

    Create an organization; you become its admin. The start page offers a tester token in one click, later under Settings → API tokens. Put it into the project .env:

    KALOKO_TOKEN=kal_…
    TYPESAFE_API_KEY=…   # optional: semantic evaluator

Then just ask your agent

The skill teaches your agent the whole loop: it writes the acceptance plan and the scenario from the task, walks the screens, evaluates, shares the canvas, reads what reviewers said and fixes it. You don’t type the commands; you look at the canvas.

  • From a task to a shared walkthrough
    Read the task in docs/tasks/TASK-123, write its acceptance plan and a Kaloko scenario, walk it on local and share the result on the pull request.

    Creates ACCEPTANCE.md and qa/scenario.yml, captures every step in each language and screen size, and posts the link.

  • Process the feedback
    Go through the open Kaloko feedback on TASK-123: fix what reviewers rejected, run the affected steps again, share, and answer each comment with what changed.

    Reads threads with kaloko feedback, resolves them with the commit that fixed them.

  • Check a public site
    Draft a Kaloko scenario for https://example.com (home, pricing, contact) with the seo, a11y and perf packs, run it on production read-only and summarise its health.

    Read-only on production; check packs add SEO, accessibility and performance checks without writing them by hand, as health apart from acceptance.

  • Keep the history tidy
    Clean up old Kaloko runs of TASK-123: show me what a prune keeping the newest 3 would remove, then do it once I agree.

    Always a dry run first; accepted, kept and commented runs stay.

What the agent runs (or run it yourself, e.g. in CI)

The same loop by hand:

npx kaloko start --scenario docs/tasks/TASK-123/qa/scenario.yml --env local
npx kaloko walk        # playwright steps; agent/manual steps: kaloko capture
npx kaloko evaluate
npx kaloko share --pr
npx kaloko feedback    # what reviewers said, with ids to answer

Data & security

The evaluator sees as little as it can

Text criteria send a reduced outline of the page with e-mail addresses and tokens masked, never the raw HTML. A screenshot goes to the vision model only for criteria marked vision and for answers the text evaluator was unsure about.

Sign-in your company already uses

A one-time e-mail link or Google, Microsoft or GitHub, with a passkey or an authenticator app as the second factor. Enterprise adds company sign-in over SAML or OIDC, and SCIM. A viewer reads and approves, a designer or developer also uploads, an admin also manages members and tokens.

Runs expire, files live apart

Every run has an expiry date (30 days by default, at most your plan’s retention) and is deleted afterwards. Uploaded files are served from a separate origin under short-lived signed links; captured HTML runs in a sandbox without scripts.

Production stays read-only

A production environment is always read-only in the CLI: public pages as a visitor, no sign-in to back offices, no data created.

Where your data lives, encryption, subprocessors and SOC 2 →

Free stays free. Paid plans start with a 14-day trial: checkout asks for a card, and if you cancel before the trial ends nothing is charged. A longer trial from an invitation code needs no card. Terms of service.

Pricing

Viewers are free and unlimited in every plan, because the people who look should never be the bottleneck. You pay for what you ship: shared runs per month, seats for the people who design, test and administer, retention, storage and hosted AI evaluation. Team and Business start with a 14-day trial. For businesses; prices exclude VAT.

Free

Free

free for good

no card needed

For one person and their agent

  • 30 shared runs / month
  • 2 seats included
  • unlimited viewers
  • AI evaluation with your own key
  • 30 days retention · 2 GB storage
  • canvas, review mode, screen library, changelog and docs
Business

199 € / month

billed monthly

yearly you save 478 €

159 € / month 199 €

billed 1,910 € yearly

you save 478 €

For several teams, clients and documentation

  • 1,500 shared runs / month
  • 25 seats included, more seats at 12 € each, up to 50more seats at 115 € / year each, up to 50
  • unlimited viewers
  • hosted AI evaluation: 5,000 questions / month
  • 365 days retention · 100 GB storage
  • hosted runs, recordings, signed acceptance records, docs per version; accepted runs stay while the plan lasts
Enterprise

30 € / seat / month

billed monthly

from 10 seats

25 € / seat / month 30 €

billed 300 € per seat yearly

from 10 seats

Governance and operations

  • 150 shared runs / month per seat, at least 1,500
  • 20 GB storage per seat, at least 200 GB
  • 500 AI questions / month per seat, at least 5,000
  • unlimited viewers
  • SSO (SAML, OIDC), SCIM, IP allowlist, audit streaming, SLA, DPA, invoice

Hosted AI evaluation comes with Team (1,000 questions a month) and Business (5,000). There is no key to manage, and answers are cached, so evaluating the same screen again costs nothing. Your own key works in every plan; deterministic checks and local previews are never limited. Compare all plans →

Questions we get

Does Kaloko replace tests?

No. Unit and end-to-end tests tell you whether the code works. Kaloko shows what was built and lets a person say whether it is what was meant.

Do I need an AI evaluator?

No. Countable criteria run without one. Judgement criteria are evaluated through Kaloko from the Team plan (1,000 questions a month, Business 5,000) or with your own key in any plan (the default is JEV by TypeSafe); without either they stay “not evaluated” until a reviewer decides.

Does it tie us to one agent or host?

No. Kaloko walks any address (local, staging, production, apps, e-mail) and works with any coding agent through the same skill, MCP server and CLI. The evaluator is replaceable, and your data stays readable through the API on every plan.

Can we see a changelog and docs made this way?

Yes, ours. Kaloko’s changelog shows our releases with screens from the runs we accepted, and Kaloko’s help is living docs whose pictures follow the newest accepted run.

What does it cost?

Free stays free. Team is 49 € and Business 199 € per month, −20 % with yearly billing, both with a 14-day trial. Data stays readable on every plan; exporting a run as a ZIP comes with Team.

Where is the data?

On Cloudflare: the app on Workers, the database in D1, files in R2, in data centres Cloudflare chooses. Kaloko is run by Sinfin, a Czech company, under Czech law. Runs are yours and expire on the date you set.

Can we use our company sign-in?

Every plan signs in with an e-mail link or Google, Microsoft or GitHub, with a passkey or an authenticator app as the second factor. Enterprise pins sign-in to your identity provider over SAML or OIDC and keeps members in sync with SCIM.