Introduction to Swamp
Swamp is a command-line automation framework designed to be operated by AI coding agents. It turns a task an agent worked out once into files you keep in Git: a YAML definition describing what to run, and a workflow describing what runs in which order. Every run records its output as structured, versioned data you can query later. It exists because a chat transcript is not something you can review, re-run, or hand to a colleague.
itInfrastructure and operations | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Introduction to Swamp
Swamp is what happens when an agent solves a useful operational problem and somebody has the good sense to keep the solution. Instead of preserving a heroic chat transcript and hoping it remembers the plot next Tuesday, Swamp keeps model definitions and workflows as files in Git. The machine-specific results of each run live separately in its data layer, which is less romantic but much more useful when something has failed.
The important split is between a model type, reusable TypeScript behavior, and a model definition, YAML that configures that behavior for one target. The type knows how to check an endpoint or call a service. Definitions name the endpoints, accounts, and timeouts. That means one repair to the behavior can reach several definitions, rather than breeding a small colony of nearly identical scripts. It also means a definition is reviewable without requiring everyone to become the author of the integration.
Then come workflows, directed graphs of jobs and steps. Work without dependencies can run in parallel, because waiting decoratively is still waiting. Dependencies say both what must finish and which outcome lets the next action begin. Use succeeded when a deployment must stop after a failed check. Use completed when a report or cleanup needs to appear precisely because the check failed. This distinction is the difference between an incident report and an unusually quiet afternoon.
The other durable part is data. A method writes a resource when later work needs structured, queryable facts, and it can write a file when the artifact itself matters. CEL expressions read those named outputs instead of making a downstream step guess at a temporary file. Retention has limits, so run history is evidence you can inspect and recreate, not an accidental infinite archive. Put secrets in a vault at runtime; putting a token in a definition is merely a very efficient way to make a future cleanup task.
Start with the Slides for the map, then use the Cheatsheet when the names, lifetimes, conditions, and commands begin to blur together. The Practice Reference builds a typed HTTP check and shows the boundaries in action. The exercise makes a failed check prove why succeeded and completed are different. The Reference tab is the route into the manual once this compact machinery has acquired a real system to operate.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://swamp-club.com/manual
Supports
- Manual navigation and official documentation structure
- https://swamp-club.com/manual/tutorials/your-first-automation
Supports
- Typed HTTP-check model example
- Parallel health-check workflow and queryable version history
- Repository initialization and definition creation
- https://swamp-club.com/manual/reference/model-definitions
Supports
- Difference between a model type and model definition
- Model-definition storage and method execution commands
- Named output specifications and model validation
- https://swamp-club.com/manual/reference/workflows
Supports
- Workflow jobs, steps, dependencies, and conditions
- Step task types model_method, workflow, manual_approval, and assert, including the required expr and message fields and the optional severity that defaults to high
- Parallel execution and completed versus succeeded conditions
- Workflow validation and execution commands
- https://git.swamp-club.com/swamp-club/swamp/src/branch/main/integration/workflow_assert_test.ts
Supports
- Upstream implementation and version floor of the assert step type
- https://swamp-club.com/manual/reference/data
Supports
- Resource and file outputs
- Versioning, data lifetimes, garbage collection, and CEL queries
- Data get, versions, and query commands
- https://swamp-club.com/manual/reference/cel-expressions
Supports
- CEL wrappers, native-type preservation, and string coercion
- data.latest, data.version, data.query, and null-safe access
- https://swamp-club.com/manual/reference/vaults
Supports
- Vault-backed secret resolution and sensitive output handling
- Vault creation and secret-management commands
- https://swamp-club.com/manual/how-to/install-swamp
Supports
- Installation and PATH verification
- https://swamp-club.com/extensions
Supports
- Extension discovery before authoring a custom integration
- https://git.swamp-club.com/swamp-club/swamp/src/branch/main
Supports
- Current official Swamp source repository
- Contribution and license material
- https://swamp-club.com/pricing
Supports
- Free single-person use and compensated-team billing conditions
- Agents and CI excluded from seat counts
- https://swamp-club.com/manual/explanation/how-swamp-works
Supports
- Swamp model definitions, workflows, versioned data, and vault-backed secret handling
- https://temporal.io/
Supports
- Temporal durable workflow execution, self-hosting, and Temporal Cloud
- https://www.prefect.io/prefect/open-source
Supports
- Prefect Python flows, task state, self-hosted orchestration, and Prefect Cloud
- https://dagster.io/platform-overview
Supports
- Dagster data-aware orchestration, asset dependencies, and managed Dagster+
- https://airflow.apache.org/docs/apache-airflow/stable/core-concepts/overview.html
Supports
- Apache Airflow Python-authored DAGs, task dependencies, scheduling, and monitoring
- https://mcginniscommawill.com/posts/2026-07-15-swamp-club-deterministic-agent-automation/
Supports
- A practitioner account of using Swamp for an unattended coding-agent autopilot
- The operational cost of manual_approval steps that suspend long-lived runs
- https://gist.github.com/sock-lint/9dedd1b27938552bc4ca59c702e6a2c5
Supports
- A practitioner migration from eleven n8n flows to Swamp workflows
- Concurrent writes to one target requiring explicit serialization with dependsOn
- Git-reviewed workflow definitions, typed reusable models, idempotency, and documented schedule offsets
