openfactory.tech

List your OpenFactory builds.

Get full details of a specific build including its recipe.

Get the current status of a build.

Create a new build from a recipe.

Start a build from one sentence — OpenFactory writes the recipe.

Build a bootable Linux ISO from one or more Git repositories.

Get artifact access details for a completed build.

Retry a failed build.

Replace a build's canonical recipe and graph.

List available pre-built recipes.

List all available recipe categories.

Get full details of a specific recipe.

Validate a recipe without creating a build.

Create a new recipe based on an existing template.

Create a reusable project test suite without requiring a built variant.

List reusable test suites accessible to the current MCP user.

View one reusable test suite and optionally its recent status history.

Bind or update a suite's named ISO slots using completed OpenFactory builds.

Run a reusable test suite against bound ISO target slots.

List test runs created from a reusable test suite.

Get a suite's authoring readiness and latest run status.

Run tests on a built ISO.

Get the results of a test run.

Return an assertion frame, recorded final display, or resumed live display.

Resume the exact VM snapshot captured by a completed test run.

List test runs for your builds.

Stop a running test run.

List your running VMs.

Create a VM from a built ISO.

Read progress for an install-to-disk VM deployment.

Start a stopped VM.

Stop a running VM.

Delete a VM.

Get the VNC console URL for a VM.

Run commands and manage files on a VM via the QEMU guest agent.

Send an SMS text message to a phone number.

Place a real-time AI voice phone call.

Check incoming SMS messages and recent call logs for your workspace.

Take a screenshot of your desktop and see what's on screen.

Capture the desktop and draw labeled highlight boxes on it, then return the annotated screenshot URL.

Click at coordinates on your desktop, then return screenshot + elements.

Drag-and-drop on your desktop: press at (x, y), move to (end_x, end_y), release.

Type text on your desktop, then return screenshot + elements.

Press a key or key combination on your desktop, then return screenshot + elements.

Close the currently active browser tab, then return screenshot + elements.

Open a URL in Brave on your desktop (falls back to Firefox or Chromium if Brave isn't installed on the VM).

Execute a sequence of actions on your desktop, then return screenshot + elements.

Run a real vision-language OCR model on a region of your desktop and return all text.

Listen to audio from a desktop VM and get transcriptions.

Speak text aloud on a desktop VM using text-to-speech.

Log your tester browser into a login-walled OpenFactory platform site so you can reproduce and VERIFY authenticated UI.

List every clickable / interactive element on the active page via DevTools.

Capture browser diagnostics — console errors, failed requests, page health.

Get-or-create your persistent desktop tester VM for an app (idempotent).

Set how many tester VMs an app keeps (explicit performance opt-in).

Start recording an app test run (one scenario execution).

Record one step of the running app test, with server-side screenshot.

Finalize an app test run with its verdict.

List app test runs (newest first), or the per-scenario verdict rollup.

Get one app test run, including per-step verdicts and screenshot refs.

Toggle whether a standalone app test report is publicly viewable.

Read a 2FA / one-time code from a Composio-connected Gmail.

Create a reusable GUI test scenario stored on OpenFactory.

List your saved GUI test scenarios.

Get a scenario's full definition, hardened cache, and last run.

Delete a saved app test scenario (its definition + hardened element cache).

Assign a scenario to a project (and optionally an existing variant), or remove it.

Run a saved scenario in a VM and record the result as an app test run.

Re-run a whole group of saved app-test scenarios in the background.

Live status of a group re-run: per-scenario status, which VM each ran on, and pass/fail counts.

Cancel a running group re-run.

Autonomously walk a web dashboard and record what's there + what breaks.

Get the full walk record: status, totals, states, transitions, findings.

List walks visible to the caller (own walks; admins see all).

Request cooperative cancellation.

Long-poll for the oldest pending harness checkpoint visible to the caller.

Submit a verdict for a paused checkpoint.

Fetch a single checkpoint (pending or resolved) by id.

Provision a managed Postgres database for an app + publish ``DATABASE_URL`` into the app's env automatically.

List databases provisioned for an app (metadata only — no passwords).

Provision a managed MinIO bucket for an app + publish AWS_* credentials into the app's env automatically.

List buckets provisioned for an app (metadata only — no secret_keys).

Provision per-app OIDC auth + auto-publish ``OF_AUTH_*`` into env.

Return the current auth binding for the app.

Generate a new client_secret + republish via producer API.

Disable per-app auth.

Capture a manual checkpoint (code SHA + VM snapshot + DB snapshot) for the app.

List checkpoints for an app (newest first) + per-app storage usage.

Bi-directional rollback.

Pin a checkpoint so the retention reconciler never deletes it.

Remove a checkpoint.

Enable code-server (Web IDE) for the app.

Stop code-server + remove the ide-<slug> gateway route.

Current IDE binding for the app: enabled flag, URL, status, timestamps.

Browse the app-templates gallery.

Full manifest for one template: source git URL, runtime defaults, env-variable spec, declared services, rendered README.

Create a new app from the template.

Fork a public+remixable app (or your own app regardless of flags).

Toggle the remixable flag on your own app.

Pin a walk as the current baseline for an app.

Get the current baseline walk for an app (your own pin).

List every baseline pin you have across all your apps.

Clear the baseline pin for an app.

Compute a diff between two walks.

Recursive BFS-tree view of a walk's UI state graph.

Serialize a walk's findings into ticket payloads ready to POST to Linear / Jira / GitHub.

Kick off a batch run of every saved scenario for this app.

Autonomously walk a website and bring back a structured map of it.

Token-bounded digest of a walked website: status + coverage, the site state tree (routes, titles, inbound actions, per-node finding counts), a findings digest (top by severity), a capability inventory (forms, inputs, internal/external links), a console/HTTP error rollup, the structural ``tree_hash``, and active-baseline status.

Seal a completed walk into an IMMUTABLE golden state tree and pin it as the active baseline for (you, app_name).

The agentic UX-regression gate.

Create a FixIntent for a walker Finding.

Apply a patch to a deployed app and restart its systemd unit.

Read one FixIntent (status, target_file, suggested_patch, apply_result).

List your FixIntents, newest first.

Mark a finding as resolved (fixed/wont_fix/duplicate/not_a_bug).

Propose a fix cycle: create FixIntents for every blocker/major finding (or NEW since baseline if supplied), up to max_findings.

List files under the build worktree's config/ directory.

Read one file from the build worktree's config/ directory.

Write (or delete) one file under the build worktree's config/.

Run preparation once across all MCP workers and expose retry-safe state.

Validate the current prepared worktree config without building.

Re-run deterministic config generation for the current recipe/worktree.

Classify the next repair surface for a failed build or test run.

Return package evidence to Apps and repair one source repository.

Run Package against Apps' repaired immutable source handoff.

Checkpoint Package-owned image inputs after a repair build.

Build the OS image by running ./build.sh via the privileged build daemon.

Report a build stage transition so the dashboard ribbon + SSE advance.

Stream a line of output into the build log (visible on the dashboard).

Match build output against the curated failure-pattern table.

Search the platform's proven build knowledge before inventing a fix.

Read the platform-owned build plan — your work list.

Mark plan items as you progress; the chat plan widget updates live.

Record a budgeted, user-visible plan revision (research → replan).

Escalate a genuine architectural fork or unsolvable problem to the user.

Record a build outcome into the build-knowledge base.

Create a build + prepared worktree WITHOUT queueing the autonomous pipeline.

Finalize a successful build: artifacts, tests, verification, record.

Start a host-side platform-website fix: an ad-hoc git branch/worktree plus a host coding session that implements + commits the change (never pushes).

Read a platform fix record: status (running | implemented | staging | staged | landing | landed | failed | stage_failed | land_failed), commit, changed files, staging/prod URLs, error details.

Stage an implemented fix onto the local dev servers (the tester VM can reach the returned staging_url).

Land a staged fix to production: verifies the green-scenario gate, then pushes via the blessed pipeline (monorepo: ai-sync-now; openfactory.tech: fast-forward main + push).

Connect a cloud account.

List your connected cloud providers (credentials always redacted).

Re-validate a cloud connection against the live provider API and refresh its status.

Remove a cloud connection and every account env var it projected.

List cloud instances (EC2 / Compute Engine / Azure VMs) for your connected providers, normalized to one schema.

Start a stopped cloud instance.

Stop a running cloud instance.

PERMANENTLY terminate a cloud instance.

Register an app (a git repo to deploy) on OpenFactory.

List your registered apps.

Get one app's full record (source, slug, status, deploy history).

Build a fresh app-baked OpenFactory variant and deploy it blue-green.

Poll an immutable app variant through build, boot, health, and cutover.

Turn a one-sentence brief into a queued immutable app deployment.

Dispatch a natural-language change to an app and have it applied for you.

Return the build/deploy status for an app plus live iteration-thread state — origin (brief + iterations), current URL, deploy history count, env version drift signal, and each in-flight change's status (queued/working/ done/failed) with the agent's result evidence.

List the app's env vars (masked — values returned as ``********``).

Upsert and/or delete env vars on an app in a single transaction.

Decrypt and return a single app env var's plaintext value.

List account-level env vars (shared defaults across all your apps).

Upsert/delete account-level env vars in a single transaction.

Decrypt and return a single account env var.

Start recording a VM's screen to a video file.

Stop a recording and finalize the video.

Get a recording's status + metadata (status, duration_ms, size_bytes, video_url).

List recordings for a VM, newest first.

Autonomously TEST a GUI workflow and report whether it works.

Fetch a packaged OpenFactory harness skill (instructions + references).

Declare (or replace) the multi-node topology for a new build plan.

Attach one node's recipe to the in-flight build plan.

Attach group-level test scenarios to the in-flight build plan.

Discard this identity's in-flight build-plan assembly.

Cross-validate the in-flight plan and fan it out as a BuildGroup.

Read a build group's per-node child statuses (fresh, merged).

Start ONE node's build in a conductor-driven build group (ordered fan-out).

Run the cross-node group test once every buildable node has built.