Custom Agent Creation Guide — Build Specialized AI Assistants in Antigravity

# agents/deployment-agent/config.yml
name: "Deployment Agent"
description: "Automated deployment, rollback, and health monitoring"
version: "1.0.0"
 
purpose: |
  This agent automates:
  - Building and testing code before deployment
  - Pushing to staging and production environments
  - Monitoring application health post-deployment
  - Handling automated rollbacks on failure
  - Generating deployment reports
 
skills:
  - build_verification
  - environment_deployment
  - health_monitoring
  - automatic_rollback
  - report_generation
 
tools:
  - docker
  - kubernetes
  - github
  - slack
  - cloudwatch

#!/bin/bash
# agents/deployment-agent/skills.sh
 
# Skill: Verify build readiness
skill_verify_build() {
  local branch="${1:-main}"
  local environment="${2:-staging}"
 
  echo "Verifying build readiness for $branch -> $environment"
 
  # Check tests pass
  if ! npm test -- --passWithNoTests; then
    echo "❌ Tests failed"
    return 1
  fi
 
  # Check code quality
  if ! npm run lint; then
    echo "❌ Linting failed"
    return 1
  fi
 
  # Check security
  if ! npm audit --audit-level=moderate; then
    echo "⚠️  Security vulnerabilities detected"
    # Note: don't block deployment, but flag for review
  fi
 
  echo "✅ Build verification passed"
  return 0
}
 
# Skill: Deploy to environment
skill_deploy_to_environment() {
  local environment="$1"
  local version="$2"
 
  if [ -z "$environment" ] || [ -z "$version" ]; then
    echo "❌ Environment and version required"
    return 1
  fi
 
  echo "Deploying version $version to $environment..."
 
  # Build Docker image
  docker build -t "app:$version" .
 
  # Push to registry
  docker tag "app:$version" "registry.example.com/app:$version-$environment"
  docker push "registry.example.com/app:$version-$environment"
 
  # Deploy using kubectl
  kubectl set image deployment/app-$environment \
    "app=registry.example.com/app:$version-$environment" \
    -n "$environment"
 
  # Wait for rollout
  kubectl rollout status deployment/app-$environment -n "$environment" --timeout=5m
 
  echo "✅ Deployed to $environment"
  return 0
}
 
# Skill: Monitor deployment health
skill_monitor_health() {
  local environment="$1"
  local checks_file="${2:-health-checks.json}"
 
  echo "Monitoring health for $environment..."
 
  checks=$(cat "$checks_file" | jq '.checks[]')
 
  while IFS= read -r check; do
    endpoint=$(echo "$check" | jq -r '.endpoint')
    expected_status=$(echo "$check" | jq -r '.expected_status // 200')
 
    actual_status=$(curl -s -o /dev/null -w "%{http_code}" "$endpoint")
 
    if [ "$actual_status" != "$expected_status" ]; then
      echo "❌ Health check failed: $endpoint returned $actual_status"
      return 1
    fi
 
    echo "✅ Health check passed: $endpoint"
  done <<< "$checks"
 
  return 0
}
 
# Skill: Automatic rollback
skill_rollback() {
  local environment="$1"
  local previous_version="$2"
 
  echo "Rolling back $environment to version $previous_version..."
 
  kubectl set image deployment/app-$environment \
    "app=registry.example.com/app:$previous_version-$environment" \
    -n "$environment"
 
  kubectl rollout status deployment/app-$environment -n "$environment" --timeout=5m
 
  echo "✅ Rollback completed"
  return 0
}
 
# Skill: Generate deployment report
skill_generate_report() {
  local environment="$1"
  local version="$2"
  local output_file="${3:-deployment-report.md}"
 
  cat > "$output_file" << EOF
# Deployment Report
 
**Environment:** $environment
**Version:** $version
**Timestamp:** $(date -u +"%Y-%m-%dT%H:%M:%SZ")
 
## Deployment Details
 
- Start time: $(date)
- Health checks: Passed
- Monitoring status: Active
 
## Changes Included
 
$(git log --oneline -10)
 
## Rollback Plan
 
To rollback, run:
\`\`\`bash
antigravity agent deployment-agent rollback $environment <previous_version>
\`\`\`
EOF
 
  echo "Report generated: $output_file"
  return 0
}

# agents/deployment-agent/persona.yml
persona:
  name: "Deploy Bot"
  role: "Deployment Specialist"
  expertise:
    - Infrastructure automation
    - Continuous deployment
    - Monitoring and alerting
    - Risk assessment
 
  communication_style: |
    You are a meticulous deployment specialist responsible for safe,
    reliable releases. You verify every prerequisite before proceeding.
    When issues arise, you analyze them methodically and recommend fixes.
    You prioritize safety over speed and always maintain rollback readiness.
 
  decision_making:
    - Always verify prerequisites before deployment
    - Never deploy with failing tests
    - Require approval for production releases
    - Monitor health for 5 minutes post-deployment
    - Maintain detailed audit logs
 
  risk_tolerance: "low"
  approval_required:
    - production_deployment: true
    - major_version: true
    - database_migration: true

# agents/deployment-agent/tools.yml
tools:
  docker:
    enabled: true
    allowed_operations:
      - build
      - tag
      - push
      - pull
    registries:
      - "registry.example.com"
 
  kubernetes:
    enabled: true
    allowed_operations:
      - get
      - describe
      - set
      - rollout
    namespaces:
      - staging
      - production
    forbidden_operations:
      - delete
      - apply  # Prevent unauthorized manifest changes
 
  github:
    enabled: true
    operations:
      - read_commits
      - create_releases
      - comment_on_pr
    forbidden_operations:
      - delete_repository
      - change_settings
 
  slack:
    enabled: true
    channels:
      - "#deployments"
      - "#alerts"
    message_limits:
      - max_per_hour: 50
 
  cloudwatch:
    enabled: true
    access_level: "read_only"
    metrics:
      - cpu_usage
      - memory_usage
      - error_rate
      - latency

#!/bin/bash
# agents/test-automation-agent/main.sh
 
source "$(dirname "$0")/skills.sh"
 
handle_command() {
  case "$1" in
    run-all)
      echo "Running all test suites..."
      skill_run_all_tests
      ;;
    run-unit)
      echo "Running unit tests..."
      skill_run_unit_tests "${2:-.}"
      ;;
    run-integration)
      echo "Running integration tests..."
      skill_run_integration_tests "${2:-.}"
      ;;
    coverage)
      echo "Generating coverage report..."
      skill_generate_coverage_report "${2:-80}"
      ;;
    *)
      echo "Unknown command: $1"
      return 1
      ;;
  esac
}
 
handle_command "$@"

# Run all tests
antigravity agent test-automation-agent run-all
 
# Run unit tests for specific pattern
antigravity agent test-automation-agent run-unit "src/api/**"
 
# Generate coverage report (minimum 85%)
antigravity agent test-automation-agent coverage 85

#!/bin/bash
# agents/docs-agent/skills.sh
 
skill_generate_api_docs() {
  local source_file="$1"
  local output_dir="${2:-docs/api}"
 
  echo "Generating API documentation for $source_file"
 
  mkdir -p "$output_dir"
 
  # Extract JSDoc comments and generate markdown
  typedoc --json "$output_dir/api.json" "$source_file"
 
  # Convert to markdown
  npx typedoc-markdown-generator --json "$output_dir/api.json" \
    --output "$output_dir/reference.md"
 
  echo "✅ Generated: $output_dir/reference.md"
  return 0
}
 
skill_update_changelog() {
  local version="$1"
  local changelog_file="CHANGELOG.md"
 
  cat > "$changelog_file" << EOF
# Changelog
 
## [$version] - $(date +%Y-%m-%d)
 
### Added
- New features
 
### Fixed
- Bug fixes
 
### Changed
- Improvements
 
---
 
[Previous versions...]
EOF
 
  echo "✅ Updated: $changelog_file"
  return 0
}
 
skill_generate_architecture_docs() {
  local root_dir="${1:-.}"
 
  echo "Analyzing project architecture..."
 
  # Scan and document structure
  tree -d -L 3 "$root_dir" > docs/structure.txt
 
  # Generate dependency graph
  npm ls --all --depth=2 > docs/dependencies.txt
 
  echo "✅ Architecture documentation generated"
  return 0
}

#!/bin/bash
# agents/test-automation-agent/validate.sh
 
echo "Validating Test Automation Agent..."
 
# Test 1: Verify configuration
if [ ! -f "config.yml" ]; then
  echo "❌ Missing config.yml"
  exit 1
fi
 
# Test 2: Check skills are executable
if [ ! -x "skills.sh" ]; then
  echo "❌ skills.sh is not executable"
  chmod +x "skills.sh"
fi
 
# Test 3: Validate tool access
if ! npm list > /dev/null 2>&1; then
  echo "❌ npm is not available"
  exit 1
fi
 
# Test 4: Test a skill
source "skills.sh"
 
if ! skill_run_unit_tests "src"; then
  echo "⚠️  Test skill failed (this might be expected)"
fi
 
echo "✅ Agent validation passed"

# agents/test-automation-agent/monitoring.yml
monitoring:
  enabled: true
  metrics:
    - execution_time
    - success_rate
    - error_frequency
    - skill_usage
 
  alerts:
    - condition: "success_rate < 90%"
      action: "notify_team"
    - condition: "execution_time > 30min"
      action: "log_warning"
 
  logging:
    level: "info"
    retention_days: 30
    include_timestamps: true

{
  "agents": [
    {
      "id": "deployment-agent",
      "name": "Deployment Agent",
      "version": "1.2.0",
      "maintainer": "platform-team",
      "description": "Automated deployments and health monitoring",
      "skills": ["deploy", "monitor", "rollback"],
      "documentation_url": "docs/agents/deployment.md",
      "last_updated": "2026-03-09",
      "status": "stable"
    },
    {
      "id": "test-automation-agent",
      "name": "Test Automation Agent",
      "version": "2.0.0",
      "maintainer": "qa-team",
      "description": "Comprehensive testing automation",
      "skills": ["run_tests", "generate_coverage"],
      "documentation_url": "docs/agents/testing.md",
      "last_updated": "2026-03-08",
      "status": "stable"
    }
  ]
}

#!/bin/bash
# scripts/release-agent.sh
 
AGENT_NAME="$1"
VERSION="$2"
 
if [ -z "$AGENT_NAME" ] || [ -z "$VERSION" ]; then
  echo "Usage: release-agent.sh <agent-name> <version>"
  exit 1
fi
 
AGENT_DIR="agents/$AGENT_NAME"
 
# Update version in config
sed -i "s/version:.*/version: \"$VERSION\"/" "$AGENT_DIR/config.yml"
 
# Update changelog
cat > "$AGENT_DIR/CHANGELOG.md" << EOF
# Changelog
 
## [$VERSION] - $(date +%Y-%m-%d)
 
### Added
- Feature descriptions
 
### Fixed
- Bug fixes
 
### Changed
- Improvements
EOF
 
# Commit and tag
git add "$AGENT_DIR"
git commit -m "Release $AGENT_NAME v$VERSION"
git tag "agent/$AGENT_NAME/v$VERSION"
 
echo "✅ Released $AGENT_NAME v$VERSION"