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

# Personas Overview

> Role-specific guidance for integrating PraisonAI recipes

Role-specific docs cover building apps, operating infrastructure, and authoring recipes.

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent

agent = Agent(
    name="Role Guide",
    instructions="Match the reader to app developer, platform, or author docs.",
)
agent.start("I am writing a new customer-support recipe.")
```

The user picks a persona card to see responsibilities, checklists, and linked guides.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph LR
    subgraph "Personas"
        U[📋 Your Role] --> A[🧭 Match Guide]
        A --> O[✅ Workflow]
    end

    classDef input fill:#6366F1,stroke:#7C90A0,color:#fff
    classDef process fill:#189AB4,stroke:#7C90A0,color:#fff
    classDef output fill:#10B981,stroke:#7C90A0,color:#fff

    class U input
    class A process
    class O output
```

## Quick Start

<Steps>
  <Step title="Simple Usage">
    Ask the router agent which persona fits your role.

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonaiagents import Agent

    agent = Agent(name="Role Guide", instructions="Match the reader to a persona guide.")
    agent.start("I am writing a new customer-support recipe.")
    ```
  </Step>

  <Step title="With Configuration">
    Give it your task and integration target for a sharper recommendation.

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonaiagents import Agent

    agent = Agent(
        name="Role Guide",
        instructions="Recommend a persona and integration model from the described task.",
    )
    agent.start("I deploy recipe infrastructure on Kubernetes for multiple tenants.")
    ```
  </Step>
</Steps>

***

## How It Works

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
sequenceDiagram
    participant User
    participant Agent
    participant Persona

    User->>Agent: Describe your role and task
    Agent->>Persona: Match to a persona guide
    Persona-->>Agent: Responsibilities + linked docs
    Agent-->>User: Recommended path
```

***

## Choose Your Persona

<CardGroup cols={2}>
  <Card title="App Developer" icon="code" href="/docs/guides/recipes/personas/app-developer">
    **Build applications** that use recipes. Focus on SDK integration, error handling, and user experience.
  </Card>

  <Card title="Platform/DevOps" icon="server" href="/docs/guides/recipes/personas/platform-devops">
    **Deploy and operate** recipe infrastructure. Focus on scaling, monitoring, security, and reliability.
  </Card>

  <Card title="Recipe Author" icon="wand-magic-sparkles" href="/docs/guides/recipes/personas/recipe-author">
    **Create and maintain** recipes. Focus on agent design, testing, and documentation.
  </Card>
</CardGroup>

## Persona Collaboration

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
flowchart TD
    subgraph Creation["Recipe Creation"]
        RA[Recipe Author] -->|creates| R[Recipe]
    end
    
    subgraph Distribution["Distribution"]
        R --> REG[(Recipe Registry)]
    end
    
    subgraph Deployment["Deployment"]
        REG --> PD[Platform/DevOps]
        PD -->|deploys| INFRA[Infrastructure]
    end
    
    subgraph Integration["Integration"]
        INFRA --> AD[App Developer]
        AD -->|integrates| APP[Application]
    end
    
    subgraph Usage["End Users"]
        APP --> EU[End Users]
    end
    
    style RA fill:#FFB6C1
    style PD fill:#87CEEB
    style AD fill:#90EE90
    classDef agent fill:#8B0000,color:#fff
    classDef tool fill:#189AB4,color:#fff
```

## Quick Reference

<Tabs>
  <Tab title="By Task">
    | Task                   | Primary Persona | Secondary     |
    | ---------------------- | --------------- | ------------- |
    | Build app with recipes | App Developer   | -             |
    | Deploy recipe server   | Platform/DevOps | -             |
    | Create new recipe      | Recipe Author   | -             |
    | Debug recipe failures  | App Developer   | Recipe Author |
    | Scale infrastructure   | Platform/DevOps | -             |
    | Optimize performance   | Platform/DevOps | App Developer |
    | Add new AI capability  | Recipe Author   | App Developer |
  </Tab>

  <Tab title="By Integration Model">
    | Model                 | Primary Persona       |
    | --------------------- | --------------------- |
    | Embedded SDK          | App Developer         |
    | CLI Invocation        | App Developer, DevOps |
    | Local HTTP Sidecar    | App Developer         |
    | Remote Managed Runner | Platform/DevOps       |
    | Event-Driven          | Platform/DevOps       |
    | Plugin Mode           | App Developer         |
  </Tab>

  <Tab title="By Concern">
    | Concern     | Primary Persona |
    | ----------- | --------------- |
    | Latency     | App Developer   |
    | Reliability | Platform/DevOps |
    | Security    | Platform/DevOps |
    | UX          | App Developer   |
    | AI Quality  | Recipe Author   |
    | Cost        | Platform/DevOps |
  </Tab>
</Tabs>

## Recommended Learning Path

### App Developer

1. Start with [Embedded SDK](/docs/guides/recipes/integration-models/embedded-sdk)
2. Learn [CLI Invocation](/docs/guides/recipes/integration-models/cli-invocation) for scripts
3. Explore [Use Cases](/docs/guides/recipes/use-cases) for patterns

### Platform/DevOps

1. Start with [Local HTTP Sidecar](/docs/guides/recipes/integration-models/local-http-sidecar)
2. Progress to [Remote Managed Runner](/docs/guides/recipes/integration-models/remote-managed-runner)
3. Learn [Event-Driven](/docs/guides/recipes/integration-models/event-driven) for scale

### Recipe Author

1. Understand all [Integration Models](/docs/guides/recipes/integration-models)
2. Study [Use Cases](/docs/guides/recipes/use-cases) for inspiration
3. Review [Decision Guide](/docs/guides/recipes/decision-guide) for recommendations

## Cross-Persona Communication

Effective recipe deployment requires collaboration:

| From            | To              | Key Handoffs                                  |
| --------------- | --------------- | --------------------------------------------- |
| Recipe Author   | App Developer   | Recipe name, input/output schema, examples    |
| Recipe Author   | Platform/DevOps | Resource requirements, dependencies, SLAs     |
| Platform/DevOps | App Developer   | Endpoint URLs, API keys, rate limits          |
| App Developer   | Recipe Author   | Bug reports, feature requests, usage patterns |

## Best Practices

<AccordionGroup>
  <Accordion title="Read the persona that matches your task, not your title">
    A backend engineer authoring a recipe should follow the Recipe Author path for that work, even if they usually build apps.
  </Accordion>

  <Accordion title="Agree handoffs across personas early">
    Recipe Authors owe App Developers a clear input/output schema and owe Platform/DevOps the resource requirements. Settle these before integration starts.
  </Accordion>

  <Accordion title="Match the integration model to the persona">
    App Developers lean on Embedded SDK and Sidecar; Platform/DevOps own Remote Runner and Event-Driven. The Quick Reference tabs above map this out.
  </Accordion>
</AccordionGroup>

***

## Next Steps

Choose your persona above to get role-specific guidance, or explore:

* [Integration Models](/docs/guides/recipes/integration-models) - Technical integration options
* [Use Cases](/docs/guides/recipes/use-cases) - Real-world implementation patterns
* [Decision Guide](/docs/guides/recipes/decision-guide) - Choosing the right approach