Plans

Reusable agent-native
validation workflows

A Plan is a reusable validation workflow authored from natural language and run against a live Sandbox. Developers and coding agents invoke it by name and get an end-to-end verdict on their change in seconds.

Start for free

Book a demo

Authored from a prompt, versioned in git

Runs against real services in seconds

Trusted by engineering teams worldwide

How it works

From prompt to reusable validation in four steps

Plans separate what to validate from how to validate it. The platform team governs the building blocks, and every developer and agent composes them into fast, repeatable checks.

Govern the Action catalog

Actions like request-http, playwright, and k6 are defined in markdown with typed inputs and outputs, versioned in git, and curated by your platform team.

Author from natural language

A developer or agent describes what should be validated. The signadot-plan skill compiles the prompt into a plan composed of catalog actions.

Tag it into the library

Plans are immutable, tagged, and carry a selection hint that tells agents when to use them. The library grows into shared coverage of your user flows.

Run on every change

The signadot-validate skill picks the right plan for a diff and runs it in a Sandbox against real services. The agent fixes what broke and re-runs until the change passes.

“We basically stopped creating full preview environments and replaced our custom solution with Signadot. The strategy using routing keys is much lighter, and we are able to provide an isolated environment, even with isolated databases, per PR quite fast.”

Marcus Tavares

Staff Software Engineer, Bitso

Validation that keeps up with agent-speed development.

Bitso scaled branch-based development for 250+ engineers and 200+ microservices on Signadot, with coding agents validating changes the same way.

Start for free Read the Bitso story

Agent skills

Two skills close the loop for coding agents

Agents interact with Plans through skills, discovering capabilities the moment they need them. One skill writes the validation, the other runs it on every change and keeps iterating until the change actually works.

SKILL

signadot-plan

Authors the validation once

A developer or agent describes what should be validated in plain language. The skill reads the action catalog, drafts the plan, runs it against your live services to confirm it works, then tags it with a selection hint and commits it alongside the code.

SKILL

signadot-validate

Runs and iterates on every change

The agent does not just get feedback it can act on. It gets feedback and iterates. The skill reads the diff, picks the matching plan, spins up a Sandbox with the change wired in, runs the plan, fixes what broke, and re-runs until the change is validated working against the real system.

claude - ~/location-service (sandbox)

Install the agent skills from the docs See the full agentic development workflow

Governed by platform teams, used by everyone

Plans give agents and developers an expressive validation vocabulary without giving up control over what runs inside the cluster.

Platform-governed catalog

The action catalog defines what validation is allowed and what it can touch. Agents compose plans from a vocabulary you control, not arbitrary scripts.

Fast enough for the inner loop

Plans run in seconds against a live Sandbox, so agents validate every iteration as they work instead of waiting for a pipeline at the end.

Versioned and rediscoverable

Tagged plans with selection hints are rediscovered and rerun across sessions and teams, so validation is written once instead of rebuilt every time.

Validate against your real system before the PR opens

Ship working, agent-generated code at scale with lightning-fast, deterministic validation that runs before the PR opens.

Start for free

Book a demo

Plans FAQ

What is a Signadot Plan?

A Plan is a small, reusable validation workflow. It is authored from a natural language prompt, compiled into a sequence of typed action invocations, and stored as a versioned artifact that developers and coding agents invoke by name. Running a plan validates a change end to end against live services in a Sandbox.

What are Actions?

Actions are the typed, deterministic building blocks Plans are composed from. The catalog includes actions like request-http for API checks, playwright for browser flows, and k6 for load scenarios. Each action is defined in markdown with declared inputs and outputs, checked into a git repo your platform team controls, and synced into the action registry.

How do coding agents use Plans?

Through two agent skills. The signadot-plan skill authors a new plan from a prompt, tags it, and gives it a selection hint. The signadot-validate skill reads a code diff, picks the matching plan by its selection hint, runs it in a Sandbox against real services, and iterates on failures until the change passes. Both work with the Signadot MCP server or fall back to the CLI.

Where do Plans execute?

Plan steps run in isolated, rootless execution environments on Plan Runner Group pods inside your Kubernetes cluster. The control plane compiles and schedules the plan, resolves parameters and secrets, and collects outputs and artifacts, while the validation traffic itself stays on your cluster.

Reusable agent-native validation workflows