diff --git a/docs/BUILD-FILE.md b/docs/BUILD-FILE.md
index ab72f2b35..536b9550c 100644
--- a/docs/BUILD-FILE.md
+++ b/docs/BUILD-FILE.md
@@ -500,3 +500,72 @@ TODO(vaikas): melange config points to apko here:
 # pipeline
 Pipeline defines the ordered steps to build the package.
 
+## Pipeline Fields
+
+Each pipeline entry can include the following fields:
+
+### name
+Optional: A user-defined name for the pipeline step. Used in logs and error messages to identify the step.
+
+### uses
+Optional: A named reusable pipeline to run. Can be either a builtin melange pipeline or a user-defined named pipeline. See [PIPELINES.md](PIPELINES.md) for more information.
+
+### with
+Optional: Arguments passed to the reusable pipelines defined in `uses`.
+
+### runs
+Optional: The command to run using the builder's shell (`/bin/sh`).
+
+### pipeline
+Optional: A list of nested pipelines to run. Each pipeline runs in its own context that is not shared between other pipelines.
+
+### if
+Optional: A condition to evaluate before running the pipeline. If the condition evaluates to false, the pipeline is skipped.
+
+### inputs
+Optional: A map of inputs to the pipeline.
+
+### needs
+Optional: Configuration to determine any explicit dependencies this pipeline may have.
+
+### label
+Optional: Labels to apply to the pipeline.
+
+### assertions
+Optional: Assertions to evaluate whether the pipeline was successful.
+
+### working-directory
+Optional: The working directory for the pipeline. Defaults to the guest's build workspace (`/home/build`).
+
+### environment
+Optional: Environment variables to override for this pipeline.
+
+### retry
+Optional: Retry configuration for this pipeline. Allows the pipeline to automatically retry on failure with configurable backoff strategies.
+
+#### Retry Configuration
+
+The `retry` field accepts the following sub-fields:
+
+- **attempts** (integer, default: 1): The number of times to attempt the pipeline execution. Must be at least 1.
+- **backoff** (string, default: "exponential"): The backoff strategy to use between retry attempts. Valid values: "constant", "linear", "exponential".
+- **initial-delay** (duration string, default: "1s"): The initial delay before the first retry attempt. Format: duration string (e.g., "1s", "500ms", "2m").
+- **max-delay** (duration string, default: "60s"): The maximum delay between retries. Prevents exponential backoff from growing too large.
+
+**Example:**
+```yaml
+pipeline:
+  - name: fetch-source
+    retry:
+      attempts: 5
+      backoff: exponential
+      initial-delay: 2s
+      max-delay: 30s
+    uses: fetch
+    with:
+      uri: https://example.com/source.tar.gz
+      expected-sha256: abc123...
+```
+
+For detailed information about retry functionality, backoff strategies, best practices, and usage examples, see [PIPELINES-RETRY.md](PIPELINES-RETRY.md).
+
diff --git a/docs/PIPELINES-RETRY.md b/docs/PIPELINES-RETRY.md
new file mode 100644
index 000000000..a953306ff
--- /dev/null
+++ b/docs/PIPELINES-RETRY.md
@@ -0,0 +1,419 @@
+# Pipeline Retry Configuration
+
+## Overview
+
+Melange supports automatic retry functionality for pipelines to improve build robustness against transient failures. When a pipeline fails, it can automatically retry from the beginning using configurable backoff strategies.
+
+## When to Use Retry
+
+Retry functionality is particularly useful for:
+
+- **Network operations**: Fetching remote resources that may experience temporary connectivity issues
+- **Flaky tests**: Tests that occasionally fail due to timing issues or external dependencies
+- **Resource contention**: Operations that may fail due to temporary resource unavailability
+- **External service dependencies**: Calls to external APIs or services that may be temporarily unavailable
+
+## Configuration
+
+Add a `retry` block to any pipeline to enable retry functionality:
+
+```yaml
+pipeline:
+  - name: my-pipeline
+    retry:
+      attempts: 3
+      backoff: exponential
+      initial-delay: 1s
+      max-delay: 60s
+    runs: ./some-command
+```
+
+### Configuration Options
+
+#### `attempts` (integer, default: 1)
+
+The number of times to attempt the pipeline execution. Must be at least 1.
+
+- If set to 1, the pipeline runs once without retries (default behavior)
+- Higher values increase resilience but may extend build time
+- Values over 10 will generate a warning
+
+**Example:**
+```yaml
+retry:
+  attempts: 5  # Try up to 5 times total
+```
+
+#### `backoff` (string, default: "exponential")
+
+The backoff strategy to use between retry attempts. Valid values:
+
+- **`exponential`** (default): Delay doubles with each retry (1s, 2s, 4s, 8s, ...)
+- **`linear`**: Delay increases by a fixed amount (1s, 2s, 3s, 4s, ...)
+- **`constant`**: Same delay between all retries (1s, 1s, 1s, 1s, ...)
+
+**Recommendations:**
+- Use `exponential` for network operations and external services (gives systems time to recover)
+- Use `linear` for resource contention issues
+- Use `constant` for simple retry scenarios with predictable failure modes
+
+**Example:**
+```yaml
+retry:
+  attempts: 4
+  backoff: linear
+```
+
+#### `initial-delay` (duration string, default: "1s")
+
+The initial delay before the first retry attempt. Accepts duration strings like:
+- `500ms` - milliseconds
+- `1s` - seconds
+- `2m` - minutes
+- `1h30m` - combined units
+
+For exponential and linear backoff, this value is the base delay that gets multiplied.
+
+**Example:**
+```yaml
+retry:
+  attempts: 3
+  initial-delay: 2s  # Wait 2 seconds before first retry
+```
+
+#### `max-delay` (duration string, default: "60s")
+
+The maximum delay between retry attempts. Prevents exponential backoff from growing too large.
+
+**Example:**
+```yaml
+retry:
+  attempts: 10
+  backoff: exponential
+  initial-delay: 1s
+  max-delay: 30s  # Cap delays at 30 seconds
+```
+
+## Behavior
+
+### Retry Logic
+
+1. Pipeline executes normally on the first attempt
+2. If the pipeline fails:
+   - Log the failure with attempt number
+   - Calculate backoff delay based on strategy
+   - Wait for the calculated delay (respecting context cancellation)
+   - Retry the pipeline from the beginning
+3. Repeat until:
+   - Pipeline succeeds (returns success)
+   - Maximum attempts reached (returns final error)
+   - Context is cancelled, e.g., via Ctrl+C (returns cancellation error)
+
+### State Between Retries
+
+**Important**: Retries do not perform any automatic cleanup. The entire pipeline re-runs from the beginning in the same environment. This means:
+
+- Files created by previous attempts remain
+- Environment variables persist
+- The working directory is not reset
+
+### Idempotency Considerations
+
+For retry to work correctly, pipelines should be designed to be **idempotent** - running them multiple times should have the same effect as running once.
+
+**Good practices:**
+```yaml
+# Use -f flag to make commands idempotent
+runs: mkdir -p /tmp/build  # creates or uses existing directory
+
+# Check for existing state
+runs: |
+  if [ ! -f config.done ]; then
+    ./configure
+    touch config.done
+  fi
+
+# Clean up before retrying
+runs: |
+  rm -rf build/
+  make clean
+  make build
+```
+
+**Avoid:**
+```yaml
+# This will fail on retry if directory exists
+runs: mkdir /tmp/build
+
+# This might produce unexpected results on retry
+runs: echo "line" >> logfile.txt
+```
+
+## Backoff Strategies Explained
+
+### Exponential Backoff (Default)
+
+Delay = 2^(attempt_number) × initial-delay, capped at max-delay
+
+**Example** with `initial-delay: 1s`, `max-delay: 60s`:
+- Attempt 1 → fails → wait 1s
+- Attempt 2 → fails → wait 2s
+- Attempt 3 → fails → wait 4s
+- Attempt 4 → fails → wait 8s
+- Attempt 5 → fails → wait 16s
+
+**Best for**: Network operations, external services, scenarios where systems need time to recover.
+
+### Linear Backoff
+
+Delay = (attempt_number + 1) × initial-delay, capped at max-delay
+
+**Example** with `initial-delay: 1s`, `max-delay: 60s`:
+- Attempt 1 → fails → wait 1s
+- Attempt 2 → fails → wait 2s
+- Attempt 3 → fails → wait 3s
+- Attempt 4 → fails → wait 4s
+- Attempt 5 → fails → wait 5s
+
+**Best for**: Resource contention, database operations, moderate backpressure scenarios.
+
+### Constant Backoff
+
+Delay = initial-delay (max-delay is ignored)
+
+**Example** with `initial-delay: 5s`:
+- Attempt 1 → fails → wait 5s
+- Attempt 2 → fails → wait 5s
+- Attempt 3 → fails → wait 5s
+- Attempt 4 → fails → wait 5s
+
+**Best for**: Simple polling scenarios, known recovery times, flaky operations with predictable timing.
+
+## Usage Examples
+
+### Example 1: Retry Network Fetch
+
+```yaml
+pipeline:
+  - name: fetch-source
+    retry:
+      attempts: 5
+      backoff: exponential
+      initial-delay: 2s
+      max-delay: 30s
+    uses: fetch
+    with:
+      uri: https://example.com/source.tar.gz
+      expected-sha256: abc123...
+```
+
+### Example 2: Retry Flaky Tests
+
+```yaml
+pipeline:
+  - name: integration-tests
+    retry:
+      attempts: 3
+    runs: make integration-test
+```
+
+### Example 3: Retry Multiple Steps Together
+
+```yaml
+pipeline:
+  - name: build-and-test
+    retry:
+      attempts: 3
+      backoff: exponential
+    pipeline:
+      - runs: ./configure
+      - runs: make
+      - runs: make test
+```
+
+If any step fails, all steps retry from the beginning.
+
+### Example 4: Different Retry Strategies
+
+```yaml
+pipeline:
+  # Quick retries for flaky network
+  - name: download-deps
+    retry:
+      attempts: 5
+      backoff: exponential
+      initial-delay: 1s
+      max-delay: 60s
+    runs: go mod download
+
+  # Slower retries for external API
+  - name: notify-service
+    retry:
+      attempts: 3
+      backoff: constant
+      initial-delay: 10s
+    runs: curl -X POST https://api.example.com/notify
+```
+
+## Nested Pipelines
+
+Each pipeline level handles its own retry configuration independently:
+
+```yaml
+pipeline:
+  - name: outer-pipeline
+    retry:
+      attempts: 2
+    pipeline:
+      - name: inner-pipeline-1
+        retry:
+          attempts: 3
+        runs: ./command1
+
+      - name: inner-pipeline-2
+        runs: ./command2
+```
+
+In this example:
+- `inner-pipeline-1` can retry up to 3 times
+- `inner-pipeline-2` has no retry (runs once)
+- If `inner-pipeline-1` exhausts its retries and still fails, `outer-pipeline` will retry both inner pipelines
+
+## Interactive Debug Mode
+
+When using melange's interactive debug mode (`--interactive-mode`):
+- The debug prompt only appears on the **final** failure, not on intermediate retry attempts
+- This prevents interrupting the automatic retry flow
+- If all retries are exhausted, you can debug the final failure state
+
+## Context Cancellation
+
+Retry loops respect context cancellation:
+- Pressing Ctrl+C will immediately stop the retry loop
+- The current pipeline execution completes, then the retry loop exits
+- Delays between retries are interruptible
+
+## Performance Considerations
+
+### Build Time Impact
+
+Retries increase build time on failure:
+- 3 attempts with exponential backoff (1s initial): ~7s additional time if all fail
+- 5 attempts with linear backoff (2s initial): ~30s additional time if all fail
+- 10 attempts with exponential backoff (1s initial, 30s max): ~4-5 minutes if all fail
+
+**Recommendations:**
+- Use retry for operations with high success rates but occasional failures
+- Avoid retry for operations that consistently fail (fix the underlying issue instead)
+- Set appropriate `max-delay` to prevent excessive wait times
+- Consider using fewer attempts with longer delays for external services
+
+### Log Verbosity
+
+Retry attempts generate additional log output:
+- Each failure logs at WARN level with attempt count
+- Each retry logs at INFO level with delay time
+- Final failure includes total attempt count
+
+## Validation Errors
+
+The following errors are caught during pipeline compilation:
+
+- **Invalid attempts**: Must be at least 1
+- **Invalid backoff**: Must be "constant", "linear", or "exponential"
+- **Invalid duration**: `initial-delay` and `max-delay` must be valid duration strings
+- **Warning for high attempts**: Values over 10 generate a warning (not an error)
+
+**Example error:**
+```
+Error: invalid retry configuration: backoff must be one of [constant linear exponential], got "custom"
+```
+
+## Best Practices
+
+1. **Design for idempotency**: Ensure your pipelines can be safely re-run
+2. **Use appropriate backoff**: Match the backoff strategy to the failure mode
+3. **Set reasonable attempts**: 3-5 attempts is usually sufficient
+4. **Cap max-delay**: Prevent exponential backoff from causing excessive delays
+5. **Log meaningful messages**: Help diagnose issues when retries are triggered
+6. **Test retry behavior**: Verify your pipelines handle retries correctly
+7. **Don't mask real issues**: Use retry for transient failures, not persistent bugs
+
+## Common Use Cases
+
+### Flaky Network Operations
+
+```yaml
+- name: fetch-dependencies
+  retry:
+    attempts: 5
+    backoff: exponential
+    initial-delay: 1s
+    max-delay: 30s
+  runs: |
+    curl --fail --max-time 30 https://cdn.example.com/deps.tar.gz
+    tar xf deps.tar.gz
+```
+
+### Flaky Test Suite
+
+```yaml
+- name: run-e2e-tests
+  retry:
+    attempts: 3
+    backoff: linear
+    initial-delay: 5s
+  runs: |
+    # Clean up any leftover test state
+    ./cleanup-test-env.sh
+    # Run tests
+    npm run test:e2e
+```
+
+### External Service Dependencies
+
+```yaml
+- name: verify-signature
+  retry:
+    attempts: 4
+    backoff: exponential
+    initial-delay: 2s
+    max-delay: 60s
+  runs: |
+    cosign verify --key cosign.pub image:tag
+```
+
+## Troubleshooting
+
+### Pipeline keeps retrying but never succeeds
+
+**Problem**: All retry attempts fail.
+
+**Solutions**:
+- Check if the underlying issue is transient or persistent
+- Review logs to identify the root cause
+- Ensure the pipeline is idempotent
+- Consider if retry is appropriate for this failure mode
+
+### Retries take too long
+
+**Problem**: Exponential backoff causes long delays.
+
+**Solutions**:
+- Reduce `max-delay` to cap the maximum wait time
+- Use linear or constant backoff instead
+- Reduce the number of `attempts`
+
+### Pipeline succeeds locally but fails with retry
+
+**Problem**: Retry logic causes unexpected behavior.
+
+**Solutions**:
+- Check for state pollution between attempts (files, environment variables)
+- Add cleanup steps at the start of your pipeline
+- Review idempotency of your commands
+
+## See Also
+
+- [BUILD-FILE.md](BUILD-FILE.md) - Complete build file reference
+- [examples/retry-example.yaml](../examples/retry-example.yaml) - Working examples
diff --git a/e2e-tests/retry-build-test.yaml b/e2e-tests/retry-build-test.yaml
new file mode 100644
index 000000000..d19880402
--- /dev/null
+++ b/e2e-tests/retry-build-test.yaml
@@ -0,0 +1,102 @@
+# E2E test for retry pipeline functionality
+# This test verifies that:
+# 1. Retry configuration is properly parsed and compiled
+# 2. Pipelines with retry fail and then succeed after retries
+# 3. Pipelines without retry work as normal (backward compatibility)
+# 4. Retry logging is correct
+
+package:
+  name: retry-test
+  version: 1.0.0
+  epoch: 0
+  description: E2E test for pipeline retry functionality
+  copyright:
+    - license: MIT
+
+environment:
+  contents:
+    packages:
+      - busybox
+
+pipeline:
+  # Test 1: Pipeline with retry that fails first then succeeds
+  - name: test-retry-mechanism
+    retry:
+      attempts: 5
+      backoff: constant
+      initial-delay: 200ms
+    runs: |
+      echo "Testing retry mechanism..."
+
+      # Use a counter file in workspace to track attempts
+      COUNTER_FILE="$HOME/.retry_test_counter"
+
+      if [ ! -f "$COUNTER_FILE" ]; then
+        echo "1" > "$COUNTER_FILE"
+        echo "First attempt - intentionally failing"
+        exit 1
+      fi
+
+      COUNTER=$(cat "$COUNTER_FILE")
+      COUNTER=$((COUNTER + 1))
+      echo "$COUNTER" > "$COUNTER_FILE"
+
+      echo "Attempt number: $COUNTER"
+
+      # Fail on first 2 attempts, succeed on 3rd
+      if [ "$COUNTER" -lt 3 ]; then
+        echo "Failing on attempt $COUNTER"
+        exit 1
+      fi
+
+      echo "SUCCESS on attempt $COUNTER!"
+      echo "Retry mechanism working correctly"
+
+  # Test 2: Pipeline with retry that succeeds immediately (no actual retries)
+  - name: test-immediate-success
+    retry:
+      attempts: 3
+      backoff: exponential
+    runs: |
+      echo "Testing immediate success with retry config..."
+      echo "This should succeed on first attempt"
+      echo "No retries should occur"
+
+  # Test 3: Pipeline without retry (backward compatibility)
+  - name: test-no-retry
+    runs: |
+      echo "Testing backward compatibility..."
+      echo "This pipeline has no retry configuration"
+      echo "Should run exactly once as before"
+
+  # Test 4: Create a test file that the test phase can verify
+  - name: create-test-marker
+    runs: |
+      mkdir -p ${{targets.destdir}}/usr/share/retry-test
+      echo "Retry tests completed successfully" > ${{targets.destdir}}/usr/share/retry-test/marker.txt
+      chmod 644 ${{targets.destdir}}/usr/share/retry-test/marker.txt
+
+test:
+  environment:
+    contents:
+      packages:
+        - busybox
+  pipeline:
+    - name: verify-retry-functionality
+      runs: |
+        echo "Verifying retry functionality in test phase..."
+
+        # Verify the marker file exists (proves build succeeded with retries)
+        if [ ! -f /usr/share/retry-test/marker.txt ]; then
+          echo "FAIL: Marker file not found"
+          exit 1
+        fi
+
+        content=$(cat /usr/share/retry-test/marker.txt)
+        if [ "$content" != "Retry tests completed successfully" ]; then
+          echo "FAIL: Marker content incorrect"
+          exit 1
+        fi
+
+        echo "PASS: Retry functionality verified"
+        echo "All retry tests completed successfully"
diff --git a/examples/retry-example.yaml b/examples/retry-example.yaml
new file mode 100644
index 000000000..ef3b4a9c3
--- /dev/null
+++ b/examples/retry-example.yaml
@@ -0,0 +1,111 @@
+# Example demonstrating retry functionality in melange pipelines
+#
+# This example shows how to use retry configuration to handle transient failures
+# such as network issues, flaky tests, or resource contention.
+
+package:
+  name: retry-example
+  version: 1.0.0
+  epoch: 0
+  description: Example package demonstrating retry functionality
+  copyright:
+    - license: MIT
+
+environment:
+  contents:
+    packages:
+      - busybox
+      - curl
+      - bash
+
+pipeline:
+  # Example 1: Simple retry on a flaky test command
+  # This pipeline will retry up to 3 times if the test fails
+  - name: flaky-test-simple
+    retry:
+      attempts: 3
+    runs: |
+      echo "Running flaky test..."
+      # Simulate a flaky test that might randomly fail
+      if [ $((RANDOM % 3)) -eq 0 ]; then
+        echo "Test passed!"
+      else
+        echo "Test failed!"
+        exit 1
+      fi
+
+  # Example 2: Retry with custom exponential backoff
+  # This is useful for network operations that might fail due to temporary issues
+  - name: fetch-with-retry
+    retry:
+      attempts: 5
+      backoff: exponential
+      initial-delay: 2s
+      max-delay: 30s
+    runs: |
+      echo "Attempting to fetch remote resource..."
+      # Simulate a network fetch that might fail
+      curl --fail --max-time 10 https://example.com/resource || exit 1
+
+  # Example 3: Retry with linear backoff
+  # Linear backoff increases the delay by a fixed amount each time
+  - name: database-operation
+    retry:
+      attempts: 4
+      backoff: linear
+      initial-delay: 1s
+      max-delay: 10s
+    runs: |
+      echo "Connecting to database..."
+      # Simulate a database operation
+      sleep 1
+      echo "Database operation complete"
+
+  # Example 4: Retry with constant backoff
+  # Constant backoff uses the same delay between all retry attempts
+  - name: api-request
+    retry:
+      attempts: 3
+      backoff: constant
+      initial-delay: 5s
+      max-delay: 60s
+    runs: |
+      echo "Making API request..."
+      # Simulate an API request
+      sleep 1
+      echo "API request successful"
+
+  # Example 5: Retry wrapping multiple pipeline steps
+  # All steps in the nested pipeline will be retried together
+  - name: build-and-test-with-retry
+    retry:
+      attempts: 3
+      backoff: exponential
+      initial-delay: 1s
+      max-delay: 60s
+    pipeline:
+      - name: configure
+        runs: |
+          echo "Configuring build..."
+          # Simulate configuration
+          sleep 1
+
+      - name: compile
+        runs: |
+          echo "Compiling source..."
+          # Simulate compilation
+          sleep 1
+
+      - name: test
+        runs: |
+          echo "Running tests..."
+          # Simulate tests
+          sleep 1
+          echo "All tests passed!"
+
+  # Example 6: No retry (default behavior)
+  # If retry is not specified, the pipeline runs once without retries
+  - name: simple-command
+    runs: |
+      echo "This command runs once without retries"
+      echo "Build complete!"
diff --git a/pkg/build/compile.go b/pkg/build/compile.go
index c5f814512..4b03ce75b 100644
--- a/pkg/build/compile.go
+++ b/pkg/build/compile.go
@@ -343,6 +343,11 @@ func (c *Compiled) compilePipeline(ctx context.Context, sm *SubstitutionMap, pip
 	// We don't care about the documented inputs.
 	pipeline.Inputs = nil
 
+	// Validate retry configuration if present
+	if err := validateRetryConfig(pipeline.Retry); err != nil {
+		return fmt.Errorf("invalid retry configuration: %w", err)
+	}
+
 	return nil
 }
 
@@ -357,6 +362,43 @@ func identity(p *config.Pipeline) string {
 	return unidentifiablePipeline
 }
 
+func validateRetryConfig(retry *config.RetryConfig) error {
+	if retry == nil {
+		return nil
+	}
+
+	// Validate attempts
+	if retry.Attempts < 1 {
+		return fmt.Errorf("attempts must be at least 1, got %d", retry.Attempts)
+	}
+
+	if retry.Attempts > 10 {
+		// This is just a warning logged to the user
+		clog.Warnf("retry attempts set to %d, which may cause long build times", retry.Attempts)
+	}
+
+	// Validate backoff strategy
+	validBackoffs := []string{"constant", "linear", "exponential"}
+	if retry.Backoff != "" && !slices.Contains(validBackoffs, retry.Backoff) {
+		return fmt.Errorf("backoff must be one of %v, got %q", validBackoffs, retry.Backoff)
+	}
+
+	// Validate duration strings
+	if retry.InitialDelay != "" {
+		if _, err := parseDuration(retry.InitialDelay, 0); err != nil {
+			return fmt.Errorf("invalid initial-delay: %w", err)
+		}
+	}
+
+	if retry.MaxDelay != "" {
+		if _, err := parseDuration(retry.MaxDelay, 0); err != nil {
+			return fmt.Errorf("invalid max-delay: %w", err)
+		}
+	}
+
+	return nil
+}
+
 func (c *Compiled) gatherDeps(ctx context.Context, pipeline *config.Pipeline) error {
 	log := clog.FromContext(ctx)
 
diff --git a/pkg/build/pipeline.go b/pkg/build/pipeline.go
index 4e3f45001..f95c9cc6b 100644
--- a/pkg/build/pipeline.go
+++ b/pkg/build/pipeline.go
@@ -25,6 +25,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"time"
 
 	apkoTypes "chainguard.dev/apko/pkg/build/types"
 	"github.com/chainguard-dev/clog"
@@ -246,7 +247,7 @@ func (r *pipelineRunner) runPipeline(ctx context.Context, pipeline *config.Pipel
 		mergedEnv := maps.Clone(envOverride)
 		maps.Copy(mergedEnv, p.Environment)
 		p.Environment = mergedEnv
-		if ran, err := r.runPipeline(ctx, &p); err != nil {
+		if ran, err := r.runPipelineWithRetry(ctx, &p); err != nil {
 			return false, fmt.Errorf("unable to run pipeline: %w", err)
 		} else if ran {
 			steps++
@@ -321,7 +322,7 @@ func (r *pipelineRunner) maybeDebug(ctx context.Context, fragment string, envOve
 
 func (r *pipelineRunner) runPipelines(ctx context.Context, pipelines []config.Pipeline) error {
 	for _, p := range pipelines {
-		if _, err := r.runPipeline(ctx, &p); err != nil {
+		if _, err := r.runPipelineWithRetry(ctx, &p); err != nil {
 			return fmt.Errorf("unable to run pipeline: %w", err)
 		}
 	}
@@ -342,6 +343,113 @@ func shouldRun(ifs string) (bool, error) {
 	return result, nil
 }
 
+// parseDuration parses a duration string, returning the default if parsing fails or string is empty.
+func parseDuration(s string, defaultDuration time.Duration) (time.Duration, error) {
+	if s == "" {
+		return defaultDuration, nil
+	}
+	d, err := time.ParseDuration(s)
+	if err != nil {
+		return 0, fmt.Errorf("invalid duration %q: %w", s, err)
+	}
+	return d, nil
+}
+
+// calculateBackoff calculates the backoff delay for a given retry attempt.
+func calculateBackoff(strategy string, attemptNum int, initialDelay, maxDelay time.Duration) time.Duration {
+	var delay time.Duration
+
+	switch strategy {
+	case "constant":
+		delay = initialDelay
+	case "linear":
+		delay = time.Duration(attemptNum+1) * initialDelay
+	case "exponential":
+		// 2^attemptNum * initialDelay
+		multiplier := 1 << attemptNum
+		delay = time.Duration(multiplier) * initialDelay
+	default:
+		// Default to exponential
+		multiplier := 1 << attemptNum
+		delay = time.Duration(multiplier) * initialDelay
+	}
+
+	return min(delay, maxDelay)
+}
+
+// runPipelineWithRetry wraps runPipeline with retry logic based on the pipeline's retry configuration.
+func (r *pipelineRunner) runPipelineWithRetry(ctx context.Context, pipeline *config.Pipeline) (bool, error) {
+	log := clog.FromContext(ctx)
+
+	// If no retry config, just run the pipeline once
+	if pipeline.Retry == nil {
+		return r.runPipeline(ctx, pipeline)
+	}
+
+	// Parse and apply defaults to retry configuration
+	attempts := max(pipeline.Retry.Attempts, 1)
+
+	backoff := pipeline.Retry.Backoff
+	if backoff == "" {
+		backoff = "exponential"
+	}
+
+	initialDelay, err := parseDuration(pipeline.Retry.InitialDelay, 1*time.Second)
+	if err != nil {
+		return false, fmt.Errorf("invalid initial-delay: %w", err)
+	}
+
+	maxDelay, err := parseDuration(pipeline.Retry.MaxDelay, 60*time.Second)
+	if err != nil {
+		return false, fmt.Errorf("invalid max-delay: %w", err)
+	}
+
+	// Execute pipeline with retry logic
+	var lastErr error
+	for attempt := range attempts {
+		if attempt > 0 {
+			// Calculate backoff delay
+			delay := calculateBackoff(backoff, attempt-1, initialDelay, maxDelay)
+
+			if id := identity(pipeline); id != unidentifiablePipeline {
+				log.Infof("retrying step %q (attempt %d/%d) after %v", id, attempt+1, attempts, delay)
+			} else {
+				log.Infof("retrying pipeline (attempt %d/%d) after %v", attempt+1, attempts, delay)
+			}
+
+			// Wait for backoff delay, respecting context cancellation
+			select {
+			case <-ctx.Done():
+				return false, ctx.Err()
+			case <-time.After(delay):
+			}
+		}
+
+		ran, err := r.runPipeline(ctx, pipeline)
+		if err == nil {
+			// Success
+			return ran, nil
+		}
+
+		lastErr = err
+
+		// If this is not the last attempt, continue to retry
+		if attempt < attempts-1 {
+			if id := identity(pipeline); id != unidentifiablePipeline {
+				log.Warnf("step %q failed (attempt %d/%d): %v", id, attempt+1, attempts, err)
+			} else {
+				log.Warnf("pipeline failed (attempt %d/%d): %v", attempt+1, attempts, err)
+			}
+		}
+	}
+
+	// All attempts exhausted
+	if id := identity(pipeline); id != unidentifiablePipeline {
+		return false, fmt.Errorf("step %q failed after %d attempts: %w", id, attempts, lastErr)
+	}
+	return false, fmt.Errorf("pipeline failed after %d attempts: %w", attempts, lastErr)
+}
+
 func expectedShaLength(shaType string) int {
 	switch shaType {
 	case "expected-sha256":
diff --git a/pkg/build/pipeline_test.go b/pkg/build/pipeline_test.go
index fae44cafe..a510d87b5 100644
--- a/pkg/build/pipeline_test.go
+++ b/pkg/build/pipeline_test.go
@@ -18,6 +18,7 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
+	"time"
 
 	"gopkg.in/yaml.v3"
 
@@ -234,3 +235,263 @@ func Test_validateWith(t *testing.T) {
 		})
 	}
 }
+
+func Test_parseDuration(t *testing.T) {
+	tests := []struct {
+		name            string
+		input           string
+		defaultDuration time.Duration
+		expected        time.Duration
+		expectError     bool
+	}{
+		{
+			name:            "empty string returns default",
+			input:           "",
+			defaultDuration: 5 * time.Second,
+			expected:        5 * time.Second,
+			expectError:     false,
+		},
+		{
+			name:            "valid duration string",
+			input:           "10s",
+			defaultDuration: 1 * time.Second,
+			expected:        10 * time.Second,
+			expectError:     false,
+		},
+		{
+			name:            "valid duration with milliseconds",
+			input:           "500ms",
+			defaultDuration: 1 * time.Second,
+			expected:        500 * time.Millisecond,
+			expectError:     false,
+		},
+		{
+			name:            "valid duration with minutes",
+			input:           "2m",
+			defaultDuration: 1 * time.Second,
+			expected:        2 * time.Minute,
+			expectError:     false,
+		},
+		{
+			name:            "invalid duration string",
+			input:           "invalid",
+			defaultDuration: 1 * time.Second,
+			expectError:     true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := parseDuration(tt.input, tt.defaultDuration)
+
+			if tt.expectError {
+				require.Error(t, err)
+				return
+			}
+
+			require.NoError(t, err)
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func Test_calculateBackoff(t *testing.T) {
+	tests := []struct {
+		name         string
+		strategy     string
+		attemptNum   int
+		initialDelay time.Duration
+		maxDelay     time.Duration
+		expected     time.Duration
+	}{
+		{
+			name:         "constant backoff",
+			strategy:     "constant",
+			attemptNum:   0,
+			initialDelay: 1 * time.Second,
+			maxDelay:     60 * time.Second,
+			expected:     1 * time.Second,
+		},
+		{
+			name:         "constant backoff attempt 5",
+			strategy:     "constant",
+			attemptNum:   5,
+			initialDelay: 2 * time.Second,
+			maxDelay:     60 * time.Second,
+			expected:     2 * time.Second,
+		},
+		{
+			name:         "linear backoff attempt 0",
+			strategy:     "linear",
+			attemptNum:   0,
+			initialDelay: 1 * time.Second,
+			maxDelay:     60 * time.Second,
+			expected:     1 * time.Second,
+		},
+		{
+			name:         "linear backoff attempt 2",
+			strategy:     "linear",
+			attemptNum:   2,
+			initialDelay: 1 * time.Second,
+			maxDelay:     60 * time.Second,
+			expected:     3 * time.Second,
+		},
+		{
+			name:         "exponential backoff attempt 0",
+			strategy:     "exponential",
+			attemptNum:   0,
+			initialDelay: 1 * time.Second,
+			maxDelay:     60 * time.Second,
+			expected:     1 * time.Second,
+		},
+		{
+			name:         "exponential backoff attempt 3",
+			strategy:     "exponential",
+			attemptNum:   3,
+			initialDelay: 1 * time.Second,
+			maxDelay:     60 * time.Second,
+			expected:     8 * time.Second,
+		},
+		{
+			name:         "exponential backoff attempt 10 capped by maxDelay",
+			strategy:     "exponential",
+			attemptNum:   10,
+			initialDelay: 1 * time.Second,
+			maxDelay:     30 * time.Second,
+			expected:     30 * time.Second,
+		},
+		{
+			name:         "default to exponential for unknown strategy",
+			strategy:     "unknown",
+			attemptNum:   2,
+			initialDelay: 1 * time.Second,
+			maxDelay:     60 * time.Second,
+			expected:     4 * time.Second,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := calculateBackoff(tt.strategy, tt.attemptNum, tt.initialDelay, tt.maxDelay)
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func Test_validateRetryConfig(t *testing.T) {
+	tests := []struct {
+		name        string
+		retry       *config.RetryConfig
+		expectError bool
+		errorMsg    string
+	}{
+		{
+			name:        "nil retry config is valid",
+			retry:       nil,
+			expectError: false,
+		},
+		{
+			name: "valid retry config with defaults",
+			retry: &config.RetryConfig{
+				Attempts: 3,
+			},
+			expectError: false,
+		},
+		{
+			name: "valid retry config with all fields",
+			retry: &config.RetryConfig{
+				Attempts:     5,
+				Backoff:      "exponential",
+				InitialDelay: "2s",
+				MaxDelay:     "30s",
+			},
+			expectError: false,
+		},
+		{
+			name: "invalid attempts (less than 1)",
+			retry: &config.RetryConfig{
+				Attempts: 0,
+			},
+			expectError: true,
+			errorMsg:    "attempts must be at least 1, got 0",
+		},
+		{
+			name: "invalid backoff strategy",
+			retry: &config.RetryConfig{
+				Attempts: 3,
+				Backoff:  "invalid",
+			},
+			expectError: true,
+			errorMsg:    "backoff must be one of [constant linear exponential], got \"invalid\"",
+		},
+		{
+			name: "invalid initial delay",
+			retry: &config.RetryConfig{
+				Attempts:     3,
+				InitialDelay: "invalid",
+			},
+			expectError: true,
+		},
+		{
+			name: "invalid max delay",
+			retry: &config.RetryConfig{
+				Attempts: 3,
+				MaxDelay: "invalid",
+			},
+			expectError: true,
+		},
+		{
+			name: "valid constant backoff",
+			retry: &config.RetryConfig{
+				Attempts: 3,
+				Backoff:  "constant",
+			},
+			expectError: false,
+		},
+		{
+			name: "valid linear backoff",
+			retry: &config.RetryConfig{
+				Attempts: 3,
+				Backoff:  "linear",
+			},
+			expectError: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateRetryConfig(tt.retry)
+
+			if tt.expectError {
+				require.Error(t, err)
+				if tt.errorMsg != "" {
+					require.Contains(t, err.Error(), tt.errorMsg)
+				}
+				return
+			}
+
+			require.NoError(t, err)
+		})
+	}
+}
+
+func Test_retryConfigUnmarshal(t *testing.T) {
+	// Test that retry configuration can be properly unmarshaled from YAML
+	yamlData := `
+name: test-pipeline
+retry:
+  attempts: 3
+  backoff: exponential
+  initial-delay: 2s
+  max-delay: 30s
+runs: echo "test"
+`
+	var pipeline config.Pipeline
+	err := yaml.Unmarshal([]byte(yamlData), &pipeline)
+	require.NoError(t, err)
+	require.NotNil(t, pipeline.Retry)
+	require.Equal(t, 3, pipeline.Retry.Attempts)
+	require.Equal(t, "exponential", pipeline.Retry.Backoff)
+	require.Equal(t, "2s", pipeline.Retry.InitialDelay)
+	require.Equal(t, "30s", pipeline.Retry.MaxDelay)
+}
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 734465806..b64399cb6 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -575,6 +575,23 @@ type PipelineAssertions struct {
 	RequiredSteps int `json:"required-steps,omitempty" yaml:"required-steps,omitempty"`
 }
 
+type RetryConfig struct {
+	// The number of attempts to execute the pipeline (minimum 1, default 1).
+	// If set to 1, no retries will occur.
+	Attempts int `json:"attempts,omitempty" yaml:"attempts,omitempty"`
+	// The backoff strategy to use between retries.
+	// Valid values: "constant", "linear", "exponential" (default: "exponential")
+	Backoff string `json:"backoff,omitempty" yaml:"backoff,omitempty"`
+	// The initial delay before the first retry.
+	// Format: duration string (e.g., "1s", "500ms", "2m")
+	// Default: "1s"
+	InitialDelay string `json:"initial-delay,omitempty" yaml:"initial-delay,omitempty"`
+	// The maximum delay between retries.
+	// Format: duration string (e.g., "60s", "5m")
+	// Default: "60s"
+	MaxDelay string `json:"max-delay,omitempty" yaml:"max-delay,omitempty"`
+}
+
 type Pipeline struct {
 	// Optional: A condition to evaluate before running the pipeline
 	If string `json:"if,omitempty" yaml:"if,omitempty"`
@@ -611,6 +628,8 @@ type Pipeline struct {
 	WorkDir string `json:"working-directory,omitempty" yaml:"working-directory,omitempty"`
 	// Optional: environment variables to override apko
 	Environment map[string]string `json:"environment,omitempty" yaml:"environment,omitempty"`
+	// Optional: Retry configuration for this pipeline
+	Retry *RetryConfig `json:"retry,omitempty" yaml:"retry,omitempty"`
 }
 
 // SHA256 generates a digest based on the text provided
@@ -1356,6 +1375,7 @@ func replacePipeline(r *strings.Replacer, in Pipeline) Pipeline {
 		Assertions:  in.Assertions,
 		WorkDir:     r.Replace(in.WorkDir),
 		Environment: replaceMap(r, in.Environment),
+		Retry:       in.Retry,
 	}
 }