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.
- 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.
83% lower change failure rate
We basically stopped creating full preview environments and replaced our custom solution with Signadot. Instead of isolating the full environment, 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 TavaresStaff Software Engineer 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.
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.
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.
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.
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.
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.