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

# Advanced Chat: Personas and Workflows

> Master Chat for different roles. SRE, DevOps, and platform engineer workflows with real examples.

# Advanced Chat: Personas & Workflows

You've learned the basics and troubleshooting. Now let's explore how different team members use Chat for their specific workflows, plus advanced features and power user tips.

<Info>
  **Role-based approach:** See how SREs, DevOps Engineers, Platform Engineers, and Developers each use Chat differently to maximize productivity.
</Info>

***

## Different Personas, Different Workflows

### SRE: "Everything is On Fire"

**Goal:** Triage and resolve production incidents FAST

**Morning routine:**

```
"Good morning! Any HIGH severity incidents?"
"Show me production pod health"
"What changed overnight?"
```

**During incident:**

```
"URGENT: What's down in production?"
↓
"Which services are affected?"
↓
"Root cause for checkout-service failure?"
↓
"How do I rollback?"
↓
"Is it fixed?"
```

**Time: 3-5 minutes** (vs. 20+ minutes)

**Post-mortem:**

```
"Summarize today's incidents"
"What was the root cause?"
"How long was each service down?"
"Export this conversation for the post-mortem doc"
```

<Tip>
  <strong>SRE Pro Tip:</strong> Use "URGENT" or "production" in your query - the agent understands priority and responds accordingly.
</Tip>

***

### DevOps Engineer: "Deploy Safely"

**Goal:** Validate and deploy without breaking things

**Pre-deployment checklist:**

```
1. "Status of api-gateway deployment?"
2. "Any recent issues with api-gateway?"
3. [Upload new-deployment.yaml via ]
4. "Validate this deployment"
5. "What's the blast radius if this fails?"
6. "Looks good - deploying now"
```

**Post-deployment verification:**

```
"How's the new api-gateway version?"
"Any errors in the logs?"
"Resource usage vs. previous version?"
```

**During rollout:**

```
"Are new pods coming up?"
"Any errors during rollout?"
"Should I continue or rollback?"
```

<Note>
  **Chat becomes your deployment co-pilot** - validates changes, monitors rollouts, suggests rollbacks if needed.
</Note>

***

### Platform Engineer: "Optimize Everything"

**Goal:** Resource efficiency and capacity planning

**Resource optimization:**

```
"Show me pods with limits less than requests"
"What pods are over-provisioned?"
"Calculate actual vs. requested resources"
"Which deployments need autoscaling?"
"Resource waste by namespace"
```

**Capacity planning:**

```
"Cluster utilization percentage?"
"How many more pods can we run?"
"Memory headroom per node?"
"Project resource needs for 2x traffic"
```

**Cost optimization:**

```
"What pods consume the most resources?"
"Show me idle resources"
"Which nodes are underutilized?"
```

<Tip>
  <strong>Platform Engineer Tip:</strong> Ask for comparisons! "Compare dev vs. prod resource usage" helps identify over-provisioning in lower environments.
</Tip>

***

### Junior Developer: "Teach Me"

**Goal:** Learn Kubernetes while working

**Learning queries:**

```
"What is a pod?"
"Explain CrashLoopBackOff in simple terms"
"Why does Kubernetes kill OOM pods?"
"What's the difference between Deployment and Pod?"
"How do resource limits work?"
```

**Exploration:**

```
"What applications are deployed here?"
"How does payment-service connect to the database?"
"What technologies are we using?"
"Show me an example of a healthy pod"
```

**Safe experimentation:**

```
"If I delete this pod, what happens?"
"What would breaking this service impact?"
"Is it safe to restart api-gateway?"
```

<Note>
  **The agent becomes a patient teacher** - explains concepts with examples from YOUR cluster, not generic docs.
</Note>

***

## Sample Workflows by Time of Day

### Morning (9 AM): Health Check

```
"Good morning! Cluster status?"
→ Get: Health %, pod counts, active incidents

"Any issues overnight?"
→ Get: Events from last 8 hours

"All clear for deploys today?"
→ Get: Risk assessment
```

**Time: 30 seconds \*\* \*\* Time: 30 seconds** Confident to start the day

***

### Afternoon (2 PM): Pre-Deployment

```
"Status of payment-service?"
→ Current state, recent issues

[Upload new-deployment.yaml]
"Validate this"
→ Security, resource, config checks

"What's the risk?"
→ Blast radius analysis

"Deploying now - monitor it"
→ Agent watches for issues
```

**Time: 2 minutes \*\* \*\* Time: 2 minutes** Safe deployment

***

### Evening (8 PM): Post-Deploy Check

```
"How's the new payment-service?"
→ Pod status, errors, metrics

"Resource usage vs. old version?"
→ Before/after comparison

"Any regressions?"
→ Error rate, latency check
```

**Time: 1 minute \*\* \*\* Time: 1 minute** Sleep well, knowing it's stable

***

### 3 AM: Incident Response

```
"URGENT: What's down?"
→ Failing pods, services affected

"Root cause?"
→ Fast RCA

"How do I fix it?"
→ Step-by-step remediation
```

**Time: 3 minutes \*\* \*\* Time: 3 minutes** Back to sleep

***

## Advanced Features

### File Upload & YAML Validation

Click\*\*\*\*to upload Kubernetes YAML files.

**Use cases:** - Pre-deployment validation

* Security audits
* Best practice checks
* Configuration review

### Example workflow:

1. Click
2. Select `deployment.yaml`
3. Agent analyzes automatically

**Sample response:**

```
Analyzed your deployment:

 Valid YAML syntax
 Resource limits defined
  Warning: No liveness probe
  Warning: Running as root
 Error: Missing imagePullSecret

Recommendations:
1. Add livenessProbe for health checks
2. Set runAsNonRoot: true
3. Create imagePullSecret

Would you like a fixed version?
```

***

### Integration with RubixKube Features

<Tabs>
  <Tab title="Chat + Dashboard">
    **Workflow:**    1. See incident spike in Dashboard
    2\. Click "Provide to Chat Context"
    3\. Chat auto-loads incident data
    4\. Ask follow-up questions

    **Example:** Dashboard shows OOMKilled → Chat explains why
  </Tab>

  <Tab title="Chat + Insights">
    **Workflow:**    1. View RCA report in Insights
    2\. Click "Discuss in Chat"
    3\. Ask detailed questions about analysis

    **Example:** "Why did you conclude memory was the root cause?"
  </Tab>

  <Tab title="Chat + Memory Engine">
    **Automatic:**    Agent queries historical incidents

    **Example:**

    ```
        You: "We have an OOMKilled incident"
        Agent: "I found 3 similar past incidents:
                - incident-123: fixed by increasing memory
                - incident-456: memory leak in code
                - incident-789: namespace quota
                
                Which fits your situation?"
    ```
  </Tab>
</Tabs>

***

## Power User Tips

<AccordionGroup>
  <Accordion title="1. Reference Incidents by Name">
    If you see an incident in Insights:

    ```
    "Analyze incident OOMKilled-20231004"
    "Tell me about the crash-loop incident"
    ```

    Agent pulls full RCA data immediately.
  </Accordion>

  <Accordion title="2. Ask for Comparisons">
    ```
    "Compare memory usage: dev vs. prod"
    "Which uses more CPU: api-gateway or checkout?"
    "Show me the diff between v1.2 and v1.3"
    ```

    Great for before/after analysis.
  </Accordion>

  <Accordion title="3. Request Historical Trends">
    ```
    "Has this pod OOMKilled before?"
    "Incident history for payment-service"
    "Crash patterns over the last week"
    ```

    Memory Engine provides historical context.
  </Accordion>

  <Accordion title="4. Chain Queries">
    Build on previous responses:

    ```
    "Show me failing pods" → Get list
    "Focus on the HIGH severity one" → Drill down
    "Show me its logs" → Get evidence
    "Explain this error" → Understand it
    "How do I fix it?" → Get solution
    ```
  </Accordion>

  <Accordion title="5. Use for Documentation">
    ```
    "Summarize this RCA"
    "Generate post-mortem for today"
    "Export the fix we applied"
    "Create runbook for this issue"
    ```

    Then click **Export conversation**  → Save as Markdown
  </Accordion>
</AccordionGroup>

***

## Query Best Practices Expanded

### DO This

<CardGroup cols={2}>
  <Card title="Include Namespace" icon="folder">
    **Good:** "Show failing pods in prod"

    **Why:** Faster, more accurate
  </Card>

  <Card title="Specify Resource Type" icon="cube">
    **Good:** "Why is pod api-gateway failing?"

    **Why:** Clearer than just "api-gateway"
  </Card>

  <Card title="Ask Follow-Ups" icon="messages">
    **Good:** "Tell me more" or "What about logs?"

    **Why:** Leverages context
  </Card>

  <Card title="Use Urgency Keywords" icon="siren">
    **Good:** "URGENT" or "production down"

    **Why:** Agent prioritizes
  </Card>
</CardGroup>

### DON'T Do This

<CardGroup cols={2}>
  <Card title="Don't Repeat Context" icon="ban">
    **Bad:** Asking full question again when in conversation

    **Why:** Agent remembers
  </Card>

  <Card title="Don't Be Too Vague" icon="question">
    **Bad:** "Fix it" (without context)

    **Why:** Agent needs to know WHAT
  </Card>

  <Card title="Don't Use kubectl Syntax" icon="terminal">
    **Bad:** "kubectl get pods -A"

    **Why:** Just ask! "Show me all pods"
  </Card>

  <Card title="Don't Assume Omniscience" icon="crystal-ball">
    **Bad:** "Why is it slow?" (which "it"?)

    **Why:** Be specific: "Why is checkout-service slow?"
  </Card>
</CardGroup>

***

## What Chat will and will not do on its own

<Info>
  Chat recommends actions. It does not apply them silently.

  * Mutating commands (`kubectl apply`, `kubectl delete`, scale, rollback, restart) and anything similar on AWS, GCP, or VMs require explicit approval before they land in your environment.
  * Guardian policies define what is approvable and by whom, per environment. Production typically needs a second reviewer, staging a single approver, lab nothing at all. You set the policy.
  * Every applied action is audited: actor, time, scope, outcome. Rollbacks are one click.

  See [Safety and Guardrails](/concepts/guardrails) for the full model.
</Info>

***

## Export & Share

Click **Export conversation**  to:

<CardGroup cols={2}>
  <Card title="Markdown Export" icon="file-lines">
    Save as .md for documentation

    **Use for:** Post-mortems, runbooks
  </Card>

  <Card title="JSON Export" icon="file-code">
    Save as .json for analysis

    **Use for:** Audit trails, automation
  </Card>

  <Card title="Share with Team" icon="share">
    Copy link (coming soon)

    **Use for:** Collaboration
  </Card>

  <Card title="Email Thread" icon="envelope">
    Send conversation (coming soon)

    **Use for:** Stakeholder updates
  </Card>
</CardGroup>

***

## Common Questions

<AccordionGroup>
  <Accordion title="How accurate are Chat responses?">
    ### Very high.

    * Responses based on REAL cluster data (not hallucinated)
    * Function calls to actual Kubernetes API
    * Evidence-based RCA
    * Validated against best practices

    **Always verify critical changes before approving, especially in production.**
  </Accordion>

  <Accordion title="Can Chat execute commands?">
    Chat drafts the commands and proposes the apply. Nothing lands in your environment without explicit approval, scoped by Guardian policies. On lab environments you can set policies to auto-approve; on production you typically require at least one human reviewer.
  </Accordion>

  <Accordion title="What if Chat can't find something?">
    The agent will:

    1. Try multiple approaches (visible in Function Calls)
    2. Ask clarifying questions
    3. Explain what it checked
    4. Suggest alternative queries

    **Example:** If pods not in `default`, asks which namespace
  </Accordion>

  <Accordion title="Is conversation data secure?">
    ### YES.

    * Encrypted in transit and at rest
    * Workspace-isolated
    * Exportable/deletable anytime
    * SOC 2 compliant
  </Accordion>

  <Accordion title="How long is conversation history kept?">
    Retention follows your plan: 7 days on Free, 30 days on Business, unlimited on Enterprise. You can delete conversations manually at any time.
  </Accordion>

  <Accordion title="Can I customize the agent?">
    ### Not yet.

    **Coming:** Custom prompts, preferred response styles, domain-specific training
  </Accordion>
</AccordionGroup>

***

## Building Your Chat Habits

<Steps>
  <Step title="Week 1: Daily Health Checks">
    Start each day with: `"Cluster health?"`

    **Goal:** Get comfortable with Chat
  </Step>

  <Step title="Week 2: Troubleshooting">
    Use Chat for EVERY pod issue

    **Goal:** Build troubleshooting muscle memory
  </Step>

  <Step title="Week 3: Learning">
    Ask 1 "why" question per day

    **Goal:** Deepen Kubernetes knowledge
  </Step>

  <Step title="Week 4: Advanced">
    Try file uploads, historical queries, comparisons

    **Goal:** Become a power user
  </Step>
</Steps>

***

## Real-World Success Patterns

### Pattern 1: Morning Standup

**Every day at 9 AM:**

```
"Cluster health?"
"Any new incidents?"
"Team can deploy today?"
```

**Result:** 30-second standup prep

***

### Pattern 2: Pre-Deploy Validation

**Before EVERY deploy:**

```
[Upload deployment.yaml]
"Validate this"
"What's the risk?"
```

**Result:** 80% fewer bad deploys

***

### Pattern 3: Incident Response Template

**When paged:**

```
"What's down?"
"Impact?"
"Root cause?"
"Fix?"
```

**Result:** Structured triage in 3 minutes

***

### Pattern 4: Learning Hour

**Friday afternoons:**

```
"Explain [concept] with examples from my cluster"
```

**Result:** Learn by doing with real infrastructure

***

## Keyboard Power User Mode

Master these shortcuts:

| Shortcut      | Use Case                   | Time Saved            |
| ------------- | -------------------------- | --------------------- |
| `⌘K`          | Jump to Chat from anywhere | 2-3 seconds           |
| `Enter`       | Send query                 | Instant               |
| `Shift+Enter` | Multi-line query           | For complex questions |
| `↑`           | Edit/retry last query      | Fix typos quickly     |
| `Esc`         | Close Chat                 | Clean workspace       |

**Pro workflow:** 1. Press `⌘K` (wherever you are)
2\. Type "chat"
3\. Type query
4\. Press Enter
5\. Get answer

**Total: 5 seconds** from thought to answer

***

## What Makes RubixKube Chat Unique

<CardGroup cols={3}>
  <Card title="Cluster-Aware" icon="server">
    Uses YOUR data, not generic knowledge
  </Card>

  <Card title="Memory-Powered" icon="database">
    Recalls past incidents automatically
  </Card>

  <Card title="RCA Integration" icon="chart-network">
    Explains detected incidents
  </Card>

  <Card title="Multi-Agent" icon="users">
    Coordinates Observer, RCA, Memory agents
  </Card>

  <Card title="Context Retention" icon="link">
    True conversation thread
  </Card>

  <Card title="Transparent" icon="eye">
    See the agent think
  </Card>
</CardGroup>

### It's not just a chatbot - it's your intelligent infrastructure co-pilot.

***

## Comparing to Other Tools

| Feature                   | Generic ChatGPT | RubixKube Chat             |
| ------------------------- | --------------- | -------------------------- |
| **Knows your cluster**    | No              | Yes - live data            |
| **Executes queries**      | No              | Yes - real Kubernetes API  |
| **Historical context**    | No              | Yes - Memory Engine        |
| **RCA integration**       | No              | Yes - incident correlation |
| **Evidence-based**        | Can hallucinate | Shows actual logs/events   |
| **Transparent reasoning** | Black box       | Shows function calls       |

### RubixKube Chat = ChatGPT + Live Cluster Data + RCA + Memory Engine

***

## Pro Tips for Mastery

<AccordionGroup>
  <Accordion title="Create Query Templates">
    Save your favorite queries:

    ```
    Daily health:    "Cluster status + incidents?"
    Pre-deploy:      "Validate [service] for deploy"
    Post-deploy:     "How's [service] after deploy?"
    Triage:          "Show HIGH severity issues"
    ```

    Paste and run daily.
  </Accordion>

  <Accordion title="Chain Queries for Complex Investigations">
    Build investigation flow:

    ```
    1. "What's failing?" → Overview
    2. "Focus on HIGH" → Prioritize
    3. "Root cause?" → Understand
    4. "Show evidence" → Verify
    5. "Fix steps?" → Remediate
    ```
  </Accordion>

  <Accordion title="Use Chat for Team Training">
    New team member onboarding:

    ```
    1. "What applications run here?"
    2. "Show me service connections"
    3. "Explain our monitoring"
    4. "What does payment-service do?"
    ```

    **Result:** Self-serve onboarding
  </Accordion>

  <Accordion title="Combine with Dashboard">
    **Best workflow:** - Dashboard: Visual overview

    * Chat: Deep dive investigation

    See spike → Click "Discuss in Chat" → Get answers
  </Accordion>

  <Accordion title="Export Important Conversations">
    For every major incident:

    1. Investigate via Chat
    2. Click **Export conversation**  3. Save as Markdown
    3. Add to post-mortem

    **Result:** Documentation writes itself
  </Accordion>
</AccordionGroup>

***

## What You Learned

<CardGroup cols={2}>
  <Card title="5 Personas" icon="users">
    How SRE, DevOps, Platform Eng, Junior Dev use Chat differently
  </Card>

  <Card title="Time-Based Workflows" icon="clock">
    Morning, afternoon, evening, 3 AM response patterns
  </Card>

  <Card title="File Upload" icon="file-arrow-up">
    YAML validation and analysis
  </Card>

  <Card title="Integrations" icon="plug">
    Chat + Dashboard + Insights + Memory Engine
  </Card>

  <Card title="Power User Shortcuts" icon="keyboard">
    Keyboard shortcuts for efficiency
  </Card>

  <Card title="Real Patterns" icon="chart-line">
    Actual workflows from production users
  </Card>
</CardGroup>

***

## Next Steps

You're now a Chat expert! Explore related concepts:

<CardGroup cols={2}>
  <Card title="How SRI Agent Works" icon="brain" href="/concepts/agent-mesh">
    Deep dive into the Agent Mesh architecture
  </Card>

  <Card title="Memory Engine" icon="database" href="/concepts/memory-engine">
    How Chat accesses historical incident data
  </Card>

  <Card title="Using RubixKube Guides" icon="book" href="/using/observing-infra">
    Day-to-day operational guides
  </Card>

  <Card title="More Tutorials" icon="graduation-cap" href="/tutorials/break-pod-image-error">
    Practice with failure scenarios
  </Card>
</CardGroup>

***

## Summary

The Chat interface transforms how you work with infrastructure:

**Natural language** replaces kubectl commands\
**Context awareness** maintains conversation thread\
**Multi-persona** support for different workflows\
**Time savings** of 84% on average\
**Learning mode** teaches Kubernetes concepts\
**RCA integration** explains detected incidents\
**Transparent reasoning** shows how agent thinks

### You're now equipped to use Chat like a pro across all scenarios!

***

## Quick Reference Card

### Print or bookmark this:

| Scenario          | Query                    | Expected Response               |
| ----------------- | ------------------------ | ------------------------------- |
| **Daily health**  | "Cluster health?"        | Health %, incidents, pod counts |
| **Find failures** | "What's failing?"        | List of unhealthy resources     |
| **Investigate**   | "Why did \[pod] fail?"   | RCA with root cause             |
| **Get logs**      | "Show logs for \[pod]"   | Filtered log output             |
| **Get fix**       | "How do I fix \[pod]?"   | kubectl commands                |
| **Verify**        | "Is \[pod] healthy?"     | Current status                  |
| **Learn**         | "Explain \[concept]"     | Educational response            |
| **Validate**      | Upload YAML + "Validate" | Security & config checks        |

***

### You've mastered Chat! Start experimenting and discover what works best for your workflow.