> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cloudthinker.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Prompt

> The complete reference for agent mentions, tool commands, and prompt patterns

CloudThinker uses a natural language interface enhanced with structured syntax. This guide is the definitive reference for communicating effectively with agents.

***

## The Problem With Traditional Cloud CLIs

Running cloud operations traditionally requires knowing the right commands for the right tool — `aws ec2 describe-instances --filters "Name=instance-state-name,Values=running"` to list running EC2 instances, `kubectl get pods --all-namespaces --field-selector=status.phase=Pending` for pending pods, `gcloud compute instances list --filter="status=RUNNING"` for GCP VMs. Each tool has different syntax, different output formats, and different ways of expressing the same concept.

This means:

* Only specialists can run operations — developers and non-engineers are locked out
* Context is lost between tools — you can't ask a question that spans AWS + K8s in one command
* Automation requires scripting expertise — connecting data from multiple tools means writing Python or bash

[CloudThinker Language](/guide/language) solves this with a unified syntax that works identically across all agents and all connected systems.

***

## How It Compares

| Approach          | Traditional CLI                                 | CloudThinker Language                                           |
| ----------------- | ----------------------------------------------- | --------------------------------------------------------------- |
| **Syntax**        | Different per tool (`aws`, `kubectl`, `gcloud`) | Single `@agent #tool [instruction]` pattern                     |
| **Access**        | Requires deep CLI expertise                     | Works for any team member                                       |
| **Cross-system**  | Requires scripting to combine tools             | Multi-agent queries in one prompt                               |
| **Output format** | Raw JSON/YAML                                   | `#dashboard`, `#report`, `#recommend` — structured and readable |
| **Context**       | Stateless per command                           | Agents remember context across a conversation                   |

***

## Syntax Overview

Every CloudThinker prompt follows this structure:

```
@agent [instruction] [#tool] [context]
```

| Component     | Required | Description                            |
| ------------- | -------- | -------------------------------------- |
| `@agent`      | Yes      | Routes the request to a specific agent |
| `instruction` | Yes      | What you want the agent to do          |
| `#tool`       | No       | Output format or capability to use     |
| `context`     | No       | Constraints, timeframes, scope         |

***

## Agent Mentions

Use `@` to direct requests to specific agents:

| Agent     | Expertise                               | When to Use                                          |
| --------- | --------------------------------------- | ---------------------------------------------------- |
| `@alex`   | Cloud infrastructure, cost, performance | Cost analysis, resource optimization, multi-cloud    |
| `@oliver` | Security, compliance, threats           | Audits, vulnerability scans, IAM, compliance         |
| `@tony`   | Databases, queries, analytics           | Query optimization, performance tuning, backups      |
| `@kai`    | Kubernetes, containers, orchestration   | Cluster management, pod optimization, scaling        |
| `@anna`   | Coordination, strategy, reporting       | Multi-agent projects, executive reports, complex ops |

### Single Agent

```bash theme={null}
@alex analyze EC2 spending trends over the last quarter
@oliver audit all S3 buckets for public access
@tony identify queries with execution time >2 seconds
@kai check pod resource utilization in production namespace
```

### Multi-Agent Collaboration

Address multiple agents for complex problems:

```bash theme={null}
@alex @tony investigate cost spike on database infrastructure
@oliver @kai audit Kubernetes RBAC and network policies
@anna coordinate security remediation across @oliver @alex @kai
```

***

## Tool Commands

Use `#` to specify output format or invoke specific capabilities:

| Tool         | Purpose                     | Example                                       |
| ------------ | --------------------------- | --------------------------------------------- |
| `#dashboard` | Interactive visualizations  | `@alex #dashboard monthly cost trends`        |
| `#report`    | Detailed analysis documents | `@oliver #report SOC 2 compliance assessment` |
| `#recommend` | Actionable recommendations  | `@tony #recommend index optimizations`        |
| `#alert`     | Monitoring notifications    | `@kai #alert when node CPU >80%`              |
| `#chart`     | Data visualizations         | `@alex #chart spending by service`            |
| `#kb`        | Knowledge base search       | `@alex #kb AWS cost optimization policies`    |

### Tool Combinations

Combine tools with agent mentions:

```bash theme={null}
@alex #dashboard #recommend cost optimization opportunities
@oliver #report #alert security findings requiring immediate action
@tony #dashboard database performance with #alert on P95 >500ms
```

### Tool-Specific Patterns

<Tabs>
  <Tab title="#dashboard">
    Creates interactive visualizations for monitoring and presentation.

    ```bash theme={null}
    # Cost dashboards
    @alex #dashboard AWS spending by service and region
    @alex #dashboard monthly cost trends with forecast

    # Performance dashboards
    @tony #dashboard query latency P50/P95/P99 over time
    @kai #dashboard cluster resource utilization by node

    # Security dashboards
    @oliver #dashboard compliance status across frameworks
    @oliver #dashboard security findings by severity
    ```
  </Tab>

  <Tab title="#report">
    Generates comprehensive analysis documents with findings and recommendations.

    ```bash theme={null}
    # Compliance reports
    @oliver #report SOC 2 Type II assessment with evidence
    @oliver #report GDPR data processing audit

    # Optimization reports
    @alex #report quarterly cost optimization summary
    @tony #report database performance analysis with recommendations

    # Executive reports
    @anna #report infrastructure health for board presentation
    ```
  </Tab>

  <Tab title="#recommend">
    Produces prioritized, actionable recommendations with implementation steps.

    ```bash theme={null}
    # Cost recommendations
    @alex #recommend reserved instance purchases based on usage
    @alex #recommend resources for right-sizing or termination

    # Performance recommendations
    @tony #recommend index changes for slow queries
    @kai #recommend HPA policies for variable workloads

    # Security recommendations
    @oliver #recommend security group rule changes
    ```
  </Tab>

  <Tab title="#alert">
    Configures monitoring alerts for proactive notification.

    ```bash theme={null}
    # Cost alerts
    @alex #alert when daily spend exceeds $5,000
    @alex #alert on resources with >50% cost increase week-over-week

    # Performance alerts
    @tony #alert when query P95 latency exceeds 500ms
    @kai #alert on pod OOMKilled events or node pressure

    # Security alerts
    @oliver #alert on security group changes allowing 0.0.0.0/0
    @oliver #alert on failed login attempts >10 per minute
    ```
  </Tab>

  <Tab title="#kb">
    Searches your organization's knowledge base.

    ```bash theme={null}
    # Policy searches
    @alex #kb cloud governance policies
    @oliver #kb:security-policies incident response procedures

    # Best practices
    @tony #kb PostgreSQL optimization best practices
    @kai #kb Kubernetes deployment standards
    ```
  </Tab>
</Tabs>

***

## Context Modifiers

Add context to narrow scope and improve accuracy:

### Timeframes

```bash theme={null}
@alex analyze spending over the last 30 days
@alex compare costs: last month vs same period last year
@tony identify slow queries from the past week
@oliver find security group changes in the last 24 hours
```

### Scope

```bash theme={null}
@alex analyze EC2 instances in us-east-1 region
@oliver audit production environment security groups
@tony check performance on the orders database
@kai review staging cluster resource allocation
```

### Thresholds

```bash theme={null}
@alex identify instances with CPU utilization <15%
@tony find queries with execution time >2 seconds
@kai flag pods requesting >2GB memory but using <500MB
@oliver find IAM roles with >50 attached policies
```

### Exclusions

```bash theme={null}
@alex recommend terminations excluding production-tagged resources
@oliver audit all buckets except backup-* prefixed ones
@tony analyze all databases excluding read replicas
```

### Priorities

```bash theme={null}
@alex #recommend cost savings prioritizing quick wins under 30 days
@oliver identify vulnerabilities, critical severity first
@tony optimize queries prioritizing those running >100x daily
```

### Combined Context

```bash theme={null}
@alex analyze EC2 instances in us-east-1
  with CPU <20% over last 30 days
  excluding production-critical
  #recommend right-sizing with projected savings

@oliver audit security groups in production
  for public access on ports 22, 3389, 3306
  #report with remediation timeline
  prioritizing internet-facing resources
```

***

## Prompt Patterns

### Pattern 1: Analysis Request

```
@agent analyze [target] [context]
```

```bash theme={null}
@alex analyze EC2 spending by instance family over last quarter
@tony analyze query patterns on production PostgreSQL cluster
@kai analyze pod scheduling efficiency across all nodes
@oliver analyze IAM permission usage for service accounts
```

### Pattern 2: Audit Request

```
@agent audit [target] for [criteria]
```

```bash theme={null}
@oliver audit S3 buckets for public access and encryption
@oliver audit IAM policies for privilege escalation paths
@alex audit infrastructure for unused or orphaned resources
@kai audit RBAC configuration against least-privilege principles
```

### Pattern 3: Optimization Request

```
@agent optimize/recommend [target] [constraints]
```

```bash theme={null}
@alex recommend cost optimizations maintaining 99.9% availability
@tony recommend index changes for queries >500ms execution time
@kai optimize pod resource requests based on actual utilization
```

### Pattern 4: Investigation Request

```
@agent investigate [issue] [scope]
```

```bash theme={null}
@alex investigate cost spike on database services last week
@tony investigate slow query performance on orders table
@kai investigate pod crash loops in payment namespace
@oliver investigate failed authentication attempts from unusual IPs
```

### Pattern 5: Coordination Request

```
@anna coordinate [project] with @agents [scope]
```

```bash theme={null}
@anna coordinate AWS to GCP migration with @alex @tony @kai
@anna coordinate security remediation with @oliver leading, @alex @kai supporting
@anna coordinate quarterly review: @alex cost, @oliver security, @tony databases, @kai containers
```

***

## Advanced Techniques

### Progressive Refinement

Start broad, then drill down based on findings:

```bash theme={null}
# Step 1: Broad overview
@alex #dashboard cloud spending trends

# Step 2: Identify problem area
@alex which services drove the November cost spike?

# Step 3: Deep dive
@alex break down RDS costs by instance type and utilization

# Step 4: Actionable recommendation
@alex #recommend RDS optimization prioritizing underutilized instances
```

### Comparative Analysis

Ask agents to compare options:

```bash theme={null}
@alex compare reserved instances vs savings plans for our EC2 usage pattern

@tony compare these approaches for database scaling:
  1. Read replicas
  2. Sharding by customer_id
  3. Migration to Aurora Serverless
  Include: cost, complexity, performance impact

@oliver compare SOC 2 vs ISO 27001 based on our customer requirements
```

### Conditional Logic

Apply business rules to recommendations:

```bash theme={null}
@alex #recommend instance right-sizing where:
  - CPU utilization <20% for >14 days
  - Not tagged as burst-capable
  - Not in auto-scaling groups
  - Savings >$50/month

@oliver prioritize security findings:
  - Critical: internet-exposed + known CVE
  - High: production + public access
  - Medium: everything else
```

### Structured Requests

For complex requirements, use structured format:

```bash theme={null}
@tony optimize database performance:
  Target: production PostgreSQL cluster
  Focus: queries running >100x daily with >500ms P95
  Constraints:
    - No schema changes requiring downtime
    - Maintain read replica compatibility
  Output: #recommend with implementation order and rollback plan
```

***

## Slack Integration

In [Slack](/guide/slack-integration), prefix with `@CloudThinker`:

```bash theme={null}
@CloudThinker alex what's our AWS spending this week?
@CloudThinker oliver any critical security findings?
@CloudThinker tony why are queries slow on production?
@CloudThinker kai check EKS cluster health
```

All syntax works identically in Slack—just add the `@CloudThinker` prefix.

***

## Quick Reference

### Agents

| Mention   | Role              | Best For                            |
| --------- | ----------------- | ----------------------------------- |
| `@alex`   | Cloud Engineer    | Cost, infrastructure, multi-cloud   |
| `@oliver` | Security Pro      | Compliance, vulnerabilities, IAM    |
| `@tony`   | Database Engineer | Queries, performance, analytics     |
| `@kai`    | K8s Engineer      | Containers, clusters, orchestration |
| `@anna`   | General Manager   | Coordination, strategy, reports     |

### Tools

| Command      | Output           | Use Case                  |
| ------------ | ---------------- | ------------------------- |
| `#dashboard` | Interactive viz  | Monitoring, presentations |
| `#report`    | Document         | Compliance, deep analysis |
| `#recommend` | Action items     | Implementation guidance   |
| `#alert`     | Notifications    | Proactive monitoring      |
| `#chart`     | Visualization    | Data trends               |
| `#kb`        | Knowledge search | Policy lookup             |

### Context Keywords

| Type      | Examples                                                  |
| --------- | --------------------------------------------------------- |
| Time      | `over last 30 days`, `since January`, `past week`         |
| Scope     | `in us-east-1`, `on production`, `for staging cluster`    |
| Threshold | `with CPU <20%`, `costing >$1000/month`, `>500ms latency` |
| Exclusion | `excluding production`, `except backup buckets`           |
| Priority  | `prioritizing quick wins`, `critical first`               |

***

## Best Practices

<CardGroup cols={2}>
  <Card title="Be Specific" icon="bullseye">
    **Good**: `@alex analyze EC2 in us-east-1 with <15% CPU over 30 days`

    **Avoid**: `@alex check our servers`
  </Card>

  <Card title="Provide Context" icon="info">
    Include environment, timeframe, and constraints for accurate results
  </Card>

  <Card title="Use Right Agent" icon="user-check">
    Match the request to agent expertise—security to [Oliver](/guide/agents/oliver), databases to [Tony](/guide/agents/tony)
  </Card>

  <Card title="Choose Right Tool" icon="wrench">
    `#dashboard` for visuals, `#report` for documents, `#recommend` for actions
  </Card>
</CardGroup>

***

## What's Next

<CardGroup cols={2}>
  <Card title="Agent Reference" icon="robot" href="/guide/agents">
    Deep dive into each agent's specific capabilities and prompt patterns
  </Card>

  <Card title="Capabilities" icon="wand-magic-sparkles" href="/guide/capabilities">
    Master #dashboard, #report, #recommend, #alert, and other output tools
  </Card>

  <Card title="Operations Hub" icon="play" href="/guide/operations-hub">
    Browse 325+ pre-built operations ready to use with this syntax
  </Card>

  <Card title="Slack Integration" icon="slack" href="/guide/slack-integration">
    Use the same syntax in Slack with the @CloudThinker prefix
  </Card>
</CardGroup>