Skip to main content
subagent CX Codex

infra-monitor — Claude Code subagent: AWS and Vercel infrastructure scan

infra-monitor scans all accessible AWS services (ECS, EC2, RDS, Lambda, S3, and others), Vercel, and GitHub Actions in one run. Returns structured JSON with per-service health status and severity-ranked anomaly flags.

MIT ★ 3,785 updated 2026-10-25

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add davepoon/buildwithclaude
/plugin install claude-ops@buildwithclaude
Open on GitHub

What infra-monitor does

infra-monitor probes every AWS service your IAM credentials grant access to: compute (ECS, EC2, Lambda), databases (RDS, DynamoDB, ElastiCache), networking (CloudFront, ALB/NLB, API Gateway, Route 53), queues (SQS, SNS), storage (S3), certificates (ACM), observability (CloudWatch, Budgets), and identity (IAM). It also checks Vercel and GitHub Actions.

It never mutates anything—pure read-only diagnostics. First validates AWS CLI presence and authentication, then pings each service with a cheap list call to determine accessibility. For accessible services, it collects detailed metrics: instance counts and states, Lambda error rates over the past hour, unattached EBS volumes, RDS status, ECS task exit codes, and stopped-task reasons.

Output is structured JSON with separate lists of accessible and inaccessible services, plus anomalies ranked by severity. Requires AWS CLI, valid credentials already configured, and access to the Vercel MCP server.

What it helps with

  • get a complete infrastructure health snapshot without switching between three AWS dashboards
  • spot unattached resources and stopped services at a glance
  • check Lambda error rates and ECS task failures in one structured output
  • validate which AWS services your current IAM user can actually reach

Example prompts for the agent

  • Scan all our accessible AWS services and Vercel, return anomalies ranked by severity
  • Check health of ECS clusters, RDS instances, and Lambda functions—any errors in the last hour?
  • Give me structured JSON of every service we can access, flagged by status

How to install infra-monitor

1Plugin marketplace

/plugin marketplace add davepoon/buildwithclaude
/plugin install claude-ops@buildwithclaude

2Manually: put the files in place

.claude/agents/infra-monitor.md

For all projects use ~/.claude/agents/. Claude delegates by the description field or an @-mention

Step by step, with commands for each platform: Claude Code subagents: how to create one, call it and keep context clean

Questions about infra-monitor

How do I install infra-monitor in Claude Code?

Run /plugin marketplace add davepoon/buildwithclaude, then /plugin install claude-ops@buildwithclaude. The agent file is at .claude/agents/infra-monitor.md.

What does infra-monitor scan?

It checks every AWS service you have IAM access to—ECS, EC2, RDS, Lambda, S3, CloudFront, load balancers, API Gateway, SQS, SNS, DynamoDB, ElastiCache, Route 53, ACM, CloudWatch, Budgets, IAM—plus Vercel and GitHub Actions.

What are the requirements?

You need AWS CLI installed and credentials configured. The subagent validates both automatically, reads the region from AWS_REGION environment variable or defaults to us-east-1, and requires Vercel MCP server access.

Source text

infra-monitor.md · MIT
---
name: infra-monitor
description: Multi-service infrastructure health checker. Probes every AWS service the caller has IAM access to (ECS, EC2, RDS, Lambda, S3, CloudFront, ALB/NLB, API Gateway, SQS, SNS, DynamoDB, ElastiCache, Route 53, ACM, CloudWatch, Budgets, IAM) plus Vercel and GitHub Actions. Returns structured JSON with service health, accessible/inaccessible service lists, and severity-ranked anomaly flags. Used by ops-fires and ops-deploy.
model: claude-sonnet-4-6
effort: medium
maxTurns: 25
tools:
  - Bash
  - Read
  - mcp__claude_ai_Vercel__list_projects
  - mcp__claude_ai_Vercel__list_deployments
  - mcp__claude_ai_Vercel__get_deployment
  - mcp__claude_ai_Vercel__get_runtime_logs
disallowedTools:
  - Write
  - Edit
  - Agent
memory: project
initialPrompt: "Probe all accessible AWS services, Vercel, and GitHub Actions. Return structured JSON with per-service status and anomaly flags."
---

# INFRA MONITOR AGENT

Scan all infrastructure the caller can reach and return structured health data. Read-only only. Never call `delete-*`, `stop-*`, `terminate-*`, `put-*`, `create-*`, `update-*`, or any mutating verb.

## Preflight

Run in order. Fail fast with JSON on any blocking error.

```bash
# 1. CLI present?
command -v aws >/dev/null 2>&1 || { echo '{"error":"aws cli not installed"}'; exit 0; }

# 2. Authenticated?
IDENTITY=$(aws sts get-caller-identity --output json --no-cli-pager 2>/dev/null) || {
  echo '{"error":"aws not authenticated"}'; exit 0;
}

# 3. Region (env override, fallback us-east-1)
REGION="${AWS_REGION:-us-east-1}"
export AWS_DEFAULT_REGION="$REGION"

# 4. Registry (optional — drives project-scoped deep scans)
REGISTRY="${CLAUDE_PLUGIN_ROOT}/scripts/registry.json"
[ -f "$REGISTRY" ] || REGISTRY="${CLAUDE_PLUGIN_ROOT}/scripts/registry.example.json"

# 5. External projects (non-repo — Shopify, Linear, Slack, Notion, custom)
EXTERNAL_JSON=$("${CLAUDE_PLUGIN_ROOT}/bin/ops-external" 2>/dev/null || echo '[]')
```

## Service discovery

Probe each service with a cheap list call. If it returns 0, the service is accessible. Capture into a shell array. Every call is wrapped in `|| true` so one AccessDenied never kills the scan.

```bash
SERVICES="ec2 ecs rds lambda s3 cloudfront elbv2 apigateway sqs sns dynamodb elasticache route53 acm cloudwatch budgets iam"
ACCESSIBLE=()
INACCESSIBLE=()

probe() {
  local svc="$1"; local cmd="$2"
  if eval "$cmd" --max-items 1 --output json --no-cli-pager >/dev/null 2>&1; then
    ACCESSIBLE+=("$svc")
  else
    INACCESSIBLE+=("$svc")
  fi
}

probe ec2         "aws ec2 describe-instances"
probe ecs         "aws ecs list-clusters"
probe rds         "aws rds describe-db-instances"
probe lambda      "aws lambda list-functions"
probe s3          "aws s3api list-buckets"
probe cloudfront  "aws cloudfront list-distributions"
probe elbv2       "aws elbv2 describe-load-balancers"
probe apigateway  "aws apigateway get-rest-apis"
probe sqs         "aws sqs list-queues"
probe sns         "aws sns list-topics"
probe dynamodb    "aws dynamodb list-tables"
probe elasticache "aws elasticache describe-cache-clusters"
probe route53     "aws route53 list-hosted-zones"
probe acm         "aws acm list-certificates"
probe cloudwatch  "aws cloudwatch describe-alarms"
probe budgets     "aws budgets describe-budgets --account-id $(echo \"$IDENTITY\" | jq -r .Account)"
probe iam         "aws iam list-users"
```

## Per-service read-only checks

Run only for services in `ACCESSIBLE`. All commands use `--output json --no-cli-pager`, all wrapped `|| true`.

### ECS (existing)

```bash
for cluster_arn in $(aws ecs list-clusters --output json --no-cli-pager 2>/dev/null | jq -r '.clusterArns[]' || true); do
  name=$(basename "$cluster_arn")
  aws ecs describe-clusters --clusters "$name" --include STATISTICS \
    --output json --no-cli-pager 2>/dev/null | \
    jq --arg c "$name" '{cluster: $c, services: .clusters[0].statistics, status: .clusters[0].status}' || true
  aws ecs list-services --cluster "$name" --output json --no-cli-pager 2>/dev/null | \
    jq -r '.serviceArns[]' | while read svc; do
    aws ecs describe-services --cluster "$name" --services "$(basename $svc)" \
      --output json --no-cli-pager 2>/dev/null | \
      jq '.services[] | {name: .serviceName, desired: .desiredCount, running: .runningCount, pending: .pendingCount, status: .status, rolloutState: (.deployments[0].rolloutState // "STABLE"), lastEvent: (.events[0].message // "none")}' || true
  done
  # Stopped task reasons
  aws ecs list-tasks --cluster "$name" --desired-status STOPPED --max-items 5 \
    --output json --no-cli-pager 2>/dev/null | jq -r '.taskArns[]' | while read t; do
    aws ecs describe-tasks --cluster "$name" --tasks "$t" \
      --output json --no-cli-pager 2>/dev/null | \
      jq '.tasks[] | {stoppedReason, stopCode, containers: [.containers[] | {name, exitCode, reason}]}' || true
  done
done
```

### EC2

```bash
aws ec2 describe-instances --output json --no-cli-pager 2>/dev/null | \
  jq '{
    running: [.Reservations[].Instances[] | select(.State.Name=="running")] | length,
    stopped: [.Reservations[].Instances[] | select(.State.Name=="stopped")] | length,
    other:   [.Reservations[].Instances[] | select(.State.Name!="running" and .State.Name!="stopped")] | length
  }' || true

# EBS volumes — unattached flagged
aws ec2 describe-volumes --output json --no-cli-pager 2>/dev/null | \
  jq '{total: (.Volumes|length), unattached: [.Volumes[] | select(.State=="available")] | length}' || true

# AMI age (own AMIs only)
aws ec2 describe-images --owners self --output json --no-cli-pager 2>/dev/null | \
  jq '[.Images[] | {id: .ImageId, created: .CreationDate}] | sort_by(.created)' || true
```

### RDS

```bash
aws rds describe-db-instances --output json --no-cli-pager 2>/dev/null | \
  jq '[.DBInstances[] | {
    id: .DBInstanceIdentifier,
    state: .DBInstanceStatus,
    engine: .Engine,
    allocated_gb: .AllocatedStorage,
    pending: (.PendingModifiedValues // {}),
    maintenance: (.PendingMaintenanceActions // [])
  }]' || true
```

### Lambda

```bash
aws lambda list-functions --output json --no-cli-pager 2>/dev/null | \
  jq '[.Functions[] | {name: .FunctionName, runtime: .Runtime, lastModified: .LastModified}]' || true

# CloudWatch error metric (last 1h) for each function — sample cap at 20
aws lambda list-functions --output json --no-cli-pager --max-items 20 2>/dev/null | \
  jq -r '.Functions[].FunctionName' | while read fn; do
  aws cloudwatch get-metric-statistics --namespace AWS/Lambda --metric-name Errors \
    --dimensions Name=FunctionName,Value="$fn" \
    --start-time "$(date -u -d '1 hour ago' +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -v-1H +%Y-%m-%dT%H:%M:%SZ)" \
    --end-time   "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
    --period 3600 --statistics Sum \
    --output json --no-cli-pager 2>/dev/null | \
    jq --arg f "$fn" '{function: $f, errors: ([.Datapoints[].Sum] | add // 0)}' || true
done
```

### S3 — FLAG public buckets

```bash
aws s3api list-buckets --output json --no-cli-pager 2>/dev/null | \
  jq -r '.Buckets[].Name' | while read b; do
  pab=$(aws s3api get-public-access-block --bucket "$b" \
    --output json --no-cli-pager 2>/dev/null | \
    jq -r '.PublicAccessBlockConfiguration | [.BlockPublicAcls, .IgnorePublicAcls, .BlockPublicPolicy, .RestrictPublicBuckets] | all' || echo "false")
  vers=$(aws s3api get-bucket-versioning --bucket "$b" \
    --output json --no-cli-pager 2>/dev/null | jq -r '.Status // "Disabled"' || echo "Unknown")
  jq -n --arg b "$b" --arg pab "$pab" --arg v "$vers" \
    '{bucket: $b, public_access_blocked: ($pab=="true"), versioning: $v}'
done
```

### CloudFront

```bash
aws cloudfront list-distributions --output json --no-cli-pager 2>/dev/null | \
  jq '[.DistributionList.Items[]? | {id: .Id, domain: .DomainName, status: .Status, enabled: .Enabled}]' || true
```

### ALB / NLB

```bash
aws elbv2 describe-load-balancers --output json --no-cli-pager 2>/dev/null | \
  jq -r '.LoadBalancers[].LoadBalancerArn' | while read lb; do
  aws elbv2 describe-target-groups --load-balancer-arn "$lb" \
    --output json --no-cli-pager 2>/dev/null | \
    jq -r '.TargetGroups[].TargetGroupArn' | while read tg; do
    aws elbv2 describe-target-health --target-group-arn "$tg" \
      --output json --no-cli-pager 2>/dev/null | \
      jq --arg tg "$tg" '{target_group: $tg, healthy: [.TargetHealthDescriptions[] | select(.TargetHealth.State=="healthy")] | length, unhealthy: [.TargetHealthDescriptions[] | select(.TargetHealth.State!="healthy")] | length}' || true
  done
done
```

### API Gateway

```bash
aws apigateway get-rest-apis --output json --no-cli-pager 2>/dev/null | \
  jq '[.items[] | {id: .id, name: .name}]' || true
```

### SQS

```bash
aws sqs list-queues --output json --no-cli-pager 2>/dev/null | \
  jq -r '.QueueUrls[]?' | while read q; do
  aws sqs get-queue-attributes --queue-url "$q" \
    --attribute-names ApproximateNumberOfMessages ApproximateNumberOfMessagesNotVisible RedrivePolicy \
    --output json --no-cli-pager 2>/dev/null | \
    jq --arg q "$q" '{queue: $q, backlog: (.Attributes.ApproximateNumberOfMessages|tonumber? // 0), in_flight: (.Attributes.ApproximateNumberOfMessagesNotVisible|tonumber? // 0), is_dlq_target: (.Attributes.RedrivePolicy != null)}' || true
done
```

### SNS

```bash
aws sns list-topics --output json --no-cli-pager 2>/dev/null | \
  jq '{topic_count: (.Topics|length)}' || true
```

### DynamoDB

```bash
aws dynamodb list-tables --output json --no-cli-pager 2>/dev/null | \
  jq -r '.TableNames[]?' | while read t; do
  aws dynamodb describe-table --table-name "$t" \
    --output json --no-cli-pager 2>/dev/null | \
    jq '.Table | {name: .TableName, status: .TableStatus, items: .ItemCount, size_bytes: .TableSizeBytes}' || true
done
```

### ElastiCache

```bash
aws elasticache describe-cache-clusters --output json --no-cli-pager 2>/dev/null | \
  jq '[.CacheClusters[] | {id: .CacheClusterId, engine: .Engine, status: .CacheClusterStatus, nodes: .NumCacheNodes}]' || true
```

### Route 53

```bash
aws route53 list-hosted-zones --output json --no-cli-pager 2>/dev/null | \
  jq '{zones: (.HostedZones|length)}' || true
aws route53 list-health-checks --output json --no-cli-pager 2>/dev/null | \
  jq '[.HealthChecks[]? | {id: .Id, type: .HealthCheckConfig.Type}]' || true
```

### ACM — FLAG expiry <30 days

```bash
aws acm list-certificates --output json --no-cli-pager 2>/dev/null | \
  jq -r '.CertificateSummaryList[]?.CertificateArn' | while read arn; do
  aws acm describe-certificate --certificate-arn "$arn" \
    --output json --no-cli-pager 2>/dev/null | \
    jq '.Certificate | {arn: .CertificateArn, domain: .DomainName, status: .Status, not_after: .NotAfter}' || true
done
```

### CloudWatch alarms

```bash
aws cloudwatch describe-alarms --state-value ALARM --output json --no-cli-pager 2>/dev/null | \
  jq '{in_alarm: (.MetricAlarms|length), alarms: [.MetricAlarms[] | {name: .AlarmName, state: .StateValue, reason: .StateReason}]}' || true
```

### Budgets

```bash
ACCOUNT=$(echo "$IDENTITY" | jq -r .Account)
aws budgets describe-budgets --account-id "$ACCOUNT" --output json --no-cli-pager 2>/dev/null | \
  jq '[.Budgets[]? | {name: .BudgetName, limit: .BudgetLimit.Amount, actual: .CalculatedSpend.ActualSpend.Amount, forecast: .CalculatedSpend.ForecastedSpend.Amount}]' || true
```

### IAM — FLAG access keys >90 days

```bash
aws iam list-users --output json --no-cli-pager 2>/dev/null | \
  jq -r '.Users[].UserName' | while read u; do
  aws iam list-access-keys --user-name "$u" --output json --no-cli-pager 2>/dev/null | \
    jq --arg u "$u" '[.AccessKeyMetadata[] | {user: $u, key_id: .AccessKeyId, status: .Status, created: .CreateDate}]' || true
done
```

### Recent ECS events (registry-driven, project-scoped)

```bash
jq -r '.projects[]? | select(.infra.ecs_clusters) | .infra.ecs_clusters[]' "$REGISTRY" 2>/dev/null | while read cluster; do
  aws ecs list-services --cluster "$cluster" --output text --query 'serviceArns[*]' --no-cli-pager 2>/dev/null | tr '\t' '\n' | while read svc_arn; do
    svc=$(basename "$svc_arn")
    aws ecs describe-services --cluster "$cluster" --services "$svc" --output json --no-cli-pager 2>/dev/null | \
      jq --arg c "$cluster" --arg s "$svc" '{cluster: $c, service: $s, events: .services[0].events[:5]}' || true
  done
done
```

### Vercel deployments

Fetch via `mcp__claude_ai_Vercel__list_projects`, then for each project call `mcp__claude_ai_Vercel__list_deployments` with limit 3.

> If Vercel MCP tools are unavailable, fall back to `vercel` CLI via Bash: `vercel list --json 2>/dev/null` for projects and `vercel inspect <url> --json 2>/dev/null` for deployment details.

### GitHub Actions (recent runs, registry-driven)

```bash
for repo in $(jq -r '.projects[]? | select(.gsd == true) | .repos[]?' "$REGISTRY" 2>/dev/null); do
  gh run list --repo "$repo" --limit 3 \
    --json status,conclusion,name,headBranch,createdAt 2>/dev/null | \
    jq --arg r "$repo" 'map(. + {repo: $r})' || true
done | jq -s 'add // []'
```

### Optional multi-region sweep

If the caller wants a multi-region view, iterate accessible regions (skip on permission error):

```bash
for r in $(aws ec2 describe-regions --query 'Regions[].RegionName' --output text --no-cli-pager 2>/dev/null); do
  AWS_DEFAULT_REGION="$r" aws cloudwatch describe-alarms --state-value ALARM \
    --output json --no-cli-pager 2>/dev/null | jq --arg r "$r" '{region: $r, in_alarm: (.MetricAlarms|length)}' || true
done
```

## Output format

```json
{
  "timestamp": "[ISO8601]",
  "account": "[aws account id]",
  "region": "[aws region]",
  "overall_health": "healthy|degraded|critical",
  "accessible_services": ["ec2", "ecs", "rds", "lambda", "s3", "cloudfront", "elbv2", "apigateway", "sqs", "sns", "dynamodb", "elasticache", "route53", "acm", "cloudwatch", "budgets", "iam"],
  "inaccessible": ["[service where CLI returned AccessDenied or errored]"],
  "services": {
    "ecs": {
      "clusters": [
        {
          "name": "[cluster]",
          "services": [
            {
              "name": "[service]",
              "desired": 0,
              "running": 0,
              "pending": 0,
              "status": "ACTIVE|INACTIVE",
              "health": "healthy|degraded|stopped",
              "last_event": "[text]"
            }
          ],
          "stopped_task_reasons": []
        }
      ]
    },
    "ec2":         { "running": 0, "stopped": 0, "other": 0, "unattached_volumes": 0, "anomalies": [] },
    "rds":         { "instances": [], "anomalies": [] },
    "lambda":      { "functions": [], "errors_last_hour": [], "anomalies": [] },
    "s3":          { "buckets": [], "public_buckets": [], "anomalies": [] },
    "cloudfront":  { "distributions": [], "anomalies": [] },
    "elbv2":       { "load_balancers": [], "target_health": [], "anomalies": [] },
    "apigateway":  { "apis": [], "anomalies": [] },
    "sqs":         { "queues": [], "backlogs": [], "anomalies": [] },
    "sns":         { "topic_count": 0, "anomalies": [] },
    "dynamodb":    { "tables": [], "anomalies": [] },
    "elasticache": { "clusters": [], "anomalies": [] },
    "route53":     { "zones": 0, "health_checks": [], "anomalies": [] },
    "acm":         { "certificates": [], "expiring_soon": [], "anomalies": [] },
    "cloudwatch":  { "in_alarm": 0, "alarms": [], "anomalies": [] },
    "budgets":     { "budgets": [], "anomalies": [] },
    "iam":         { "stale_access_keys": [], "anomalies": [] }
  },
  "vercel": {
    "projects": [
      {
        "name": "[project]",
        "latest_deployment": {
          "id": "[id]",
          "state": "READY|ERROR|BUILDING",
          "url": "[url]",
          "created_at": "[ISO8601]"
        }
      }
    ]
  },
  "ci": { "recent_runs": [] },
  "external_projects": [
    {
      "alias": "[alias]",
      "source": "shopify|linear|slack|notion|custom",
      "status": "healthy|auth_expired|unreachable|degraded|not_configured|discovered",
      "details": {}
    }
  ],
  "anomalies": [
    {
      "severity": "critical|high|medium|low",
      "service": "[name]",
      "issue": "[description]",
      "resource": "[arn or id]",
      "since": "[ISO8601]"
    }
  ]
}
```

The `anomalies` array is sorted highest-severity first and aggregates all per-service flags so callers can triage without walking the whole tree.

## Fire detection rules

Flag as `critical` if:

- ECS service running < desired AND running == 0
- RDS instance state in {failed, storage-full, incompatible-parameters, incompatible-restore}
- S3 bucket public access NOT blocked on all four flags
- ACM certificate expires in <7 days
- CloudWatch alarm count in ALARM state > 0 on a resource marked critical in registry
- Vercel deployment state == "ERROR" on production
- CI conclusion == "failure" on `main` or `dev` branch
- External project status == "unreachable" (service may be down)

Flag as `high` if:

- ECS service running < desired (partial)
- EC2 instance in state other than running/stopped (e.g., stopping, terminated recently)
- Lambda errors > 10 in last hour
- SQS DLQ depth > 0 OR queue backlog > 1000
- ACM certificate expires in <30 days
- IAM access key active >90 days
- RDS pending maintenance actions present
- Vercel deployment state == "ERROR" on preview
- CI failure on feature branch with open PR
- External project status == "auth_expired" (credential rotation needed)

Flag as `medium` if:

- EBS volume unattached
- DynamoDB throttle events in last hour
- ElastiCache evictions rising
- CloudWatch alarm in INSUFFICIENT_DATA

Flag as `low` for informational findings (AMI age, versioning disabled on non-critical buckets, etc.).

## Rules

- Read-only only — never run any mutating AWS verb.
- Registry-driven — all project-specific inputs (clusters, repos, critical-resource marks) come from `$REGISTRY`, never hardcoded.
- Region — read from `$AWS_REGION` env, default `us-east-1`. Never hardcode a region.
- Account — read from `aws sts get-caller-identity`. Never hardcode an account ID.
- No personal data — follow Rule 0 in `claude-ops/CLAUDE.md`. Do not echo user names, emails, or real resource ARNs into logs beyond what the structured JSON requires.
- Graceful degradation — a service that returns AccessDenied goes into `inaccessible`, never crashes the scan.
- Print only the JSON to stdout.

© Lifecycle Innovations Limited · MIT · davepoon/buildwithclaude

Similar subagents

All subagents for DevOps and infrastructure →

From the same set235

The whole set →
project-timeline-simulator project-timeline-simulator — a command for Claude Code and Cursor that simulates project timelines across multiple scenarios, accounting for uncertainty, dependencies, and resource constraints. CX Codex +1 ★ 3,785repo stars ops-gtm ops-gtm builds a go-to-market plan across paid, organic, sales and AI-automation channels, then hands off executable campaigns to /marketing. CX Codex +1 ★ 3,785repo stars ops-ecom ops-ecom is a Claude Code skill that connects to Shopify Admin API to check orders, inventory, and fulfillment. CX Codex +1 ★ 3,785repo stars gsd-project-researcher gsd-project-researcher researches a project’s technical ecosystem and writes findings for roadmap planning. The /gsd:new-project and /gsd:new-milestone orchestrators spawn it. CX Codex ★ 3,785repo stars second-deposit-igaming second-deposit-igaming analyzes casino back-office exports, attributes drop-offs to 12 reasons, and exports CRM rescue lists. Built for iGaming retention teams, 21+. CX Codex +1 ★ 3,785repo stars ops-orchestrate ops-orchestrate is a Claude Code skill that audits registered projects, assigns dependent tasks to agents, and ships PRs. It can scope work to one repository or scan the registry. CX Codex +1 ★ 3,785repo stars gsd-roadmapper gsd-roadmapper builds project roadmaps broken into phases with observable success criteria for Claude Code. Works with the new project orchestrator. CX Codex ★ 3,785repo stars gsd-codebase-mapper gsd-codebase-mapper — a subagent that explores your codebase by focus area (tech stack, architecture, code quality, technical debt) and writes structured analysis documents directly into your project. CX Codex ★ 3,785repo stars

Project sponsors

Companies that keep this analytics open