---
name: Phinite
description: Use when building AI-powered assistants, designing multi-agent workflows, creating custom tools, configuring triggers and intents, deploying to production environments, or monitoring assistant performance and usage.
metadata:
    mintlify-proj: phinite
    version: "1.0"
---

# Phinite Skill Reference

## Product Summary

Phinite is an AI automation platform for building, orchestrating, and deploying intelligent assistants and multi-agent workflows across channels, tools, and business processes. Agents use Phinite to design visual workflows (Graph Studio), build reusable tools (DevStudio), configure how assistants are triggered (Intents/Triggers), manage deployments across environments (Builds), and monitor performance (Observability).

**Primary docs**: https://docs.phinite.ai/docs

**Key components**:
- **Graph Studio**: Visual workflow builder for agent graphs
- **DevStudio**: Tool builder for custom integrations and logic
- **Assistants**: Conversational, Email, or Autonomous AI capabilities
- **Intents/Triggers**: How assistants are invoked (user utterances or webhooks)
- **Builds & Environments**: Versioned deployments across Dev/UAT/Prod
- **Observability**: Session logs, metrics, and usage tracking

## When to Use

Reach for this skill when:
- **Building assistants**: Creating conversational, email, or autonomous AI agents
- **Designing workflows**: Orchestrating multi-step processes with conditional logic and tool calls
- **Creating tools**: Building custom integrations, APIs, or data transformations
- **Configuring interactions**: Setting up intents (for chat/email) or triggers (for automation)
- **Deploying to production**: Creating builds, managing environments, and publishing flows
- **Debugging issues**: Reviewing execution logs, session timelines, and error codes
- **Monitoring usage**: Tracking token consumption, session counts, and performance metrics
- **Integrating systems**: Connecting to 21+ prebuilt integrations (Slack, Jira, Salesforce, etc.)

## Quick Reference

### Assistant Types

| Type | Use Case | Triggers | Channels |
|------|----------|----------|----------|
| **Conversational** | Real-time chat/voice | Intents, chat events | Web Chat, WhatsApp, Slack, Teams, Twilio |
| **Email** | Inbox automation | Inbound email | Email |
| **Autonomous** | Background jobs, scheduled tasks | Webhooks, cron, API | Custom APIs, Jira |

### Node Types in Graph Studio

| Node | Purpose |
|------|---------|
| **Start** | Graph entry point; one source handle |
| **Master Agent** | Core reasoning unit with prompt, tools, RAG, variables |
| **Child Agent** | Helper agent for specific LLM tasks |
| **Tool** | External API/tool call node |
| **End** | Terminal node for completion |

### User Roles & Permissions

| Role | Create Graphs | Edit Graphs | Publish | View Logs |
|------|---------------|------------|---------|-----------|
| **SuperAdmin** | ✅ | ✅ | ✅ | ✅ |
| **Admin** | ✅ | ✅ | ✅ | ✅ |
| **Developer** | ✅ | ✅ | ❌ | ✅ |
| **Tester** | ❌ | ❌ | ❌ | ✅ |
| **Viewer** | ❌ | ❌ | ❌ | ❌ |

### Build Lifecycle Stages

1. **Draft**: Flows/tools under active development
2. **Validated**: Passes checks and tests
3. **Published**: Version created with release notes
4. **Deployed**: Running in target environment

### Common API Patterns

```bash
# Trigger a webhook
curl -X POST 'https://api.example.com/api/triggers/webhook/flow_123' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"event":"order.created","data":{"orderId":"12345"}}'

# Response
{ "status": "accepted", "triggerId": "trig_abc" }
```

## Decision Guidance

### When to Use Aura vs Manual Graph Creation

| Scenario | Use Aura | Use Manual |
|----------|----------|-----------|
| **Speed needed** | ✅ Fast bootstrap | ❌ Slower |
| **Complex logic** | ❌ May need refinement | ✅ Full control |
| **Learning Phinite** | ❌ Less understanding | ✅ Better learning |
| **Precise control** | ❌ Limited | ✅ Complete |
| **First-time build** | ✅ Good starting point | ⚠️ Can work |

**Recommendation**: Start with Aura for fast creation, then refine manually for precise control.

### When to Use Copilot Tools vs Manual Coding

| Scenario | Copilot | Manual |
|----------|---------|--------|
| **Quick prototyping** | ✅ Fast | ❌ Slower |
| **Complex logic** | ❌ Limited | ✅ Full power |
| **Sensitive operations** | ❌ Less control | ✅ Full control |
| **Error handling** | ⚠️ Basic | ✅ Robust |
| **Integration testing** | ❌ Limited | ✅ Full |

**Recommendation**: Use Copilot to bootstrap, switch to manual coding for production tools.

### Conversational vs Autonomous Assistants

| Need | Conversational | Autonomous |
|------|---|---|
| **Real-time user interaction** | ✅ | ❌ |
| **Scheduled/event-driven tasks** | ❌ | ✅ |
| **Chat/voice channels** | ✅ | ❌ |
| **Background processing** | ❌ | ✅ |
| **Webhook triggers** | ❌ | ✅ |

## Workflow

### Building a New Assistant (End-to-End)

1. **Create the assistant**
   - Navigate to Assistants → Create Assistant
   - Choose type: Conversational, Email, or Autonomous
   - Name the assistant

2. **Design the agent graph**
   - Open Graph Studio tab
   - Choose creation method: Aura (fast) or Manual (precise)
   - Add nodes: Start → Agent → Tool → End
   - Configure agent prompt, tools, RAG, and variables
   - Connect nodes with edges and conditional logic

3. **Configure intents or triggers**
   - For Conversational/Email: Create intents with intent phrases
   - For Autonomous: Create triggers (webhook, cron, API)
   - Link intents/triggers to your agent graph

4. **Test the flow**
   - Click "Test Agent Graph" in Graph Studio
   - Send test messages or trigger events
   - Review execution logs in the timeline
   - Verify node-by-node execution and variable capture

5. **Build and deploy**
   - Go to Builds page
   - Create a build: select intents, agent graphs, tools, and versions
   - Attach build to target environment (Dev/UAT/Prod)
   - For Conversational: Add assistant to channel (Web, Slack, Teams, etc.)

6. **Monitor in production**
   - Check Observability → Usage Metrics for sessions and tokens
   - Review Logs for execution traces and errors
   - Filter by time, user, assistant, or environment

### Creating a Custom Tool

1. **Navigate to DevStudio**
   - Go to Tools → Create Tool

2. **Choose method**
   - Copilot: Describe functionality; AI drafts the tool
   - Manual: Write Python code with handlers and schemas

3. **Define input/output schemas**
   - Specify parameter types and validation
   - Document expected outputs

4. **Test the tool**
   - Run with sample inputs in DevStudio
   - Test in multiple environments

5. **Publish and version**
   - Increment version number with meaningful notes
   - Publish to make available in Graph Studio

6. **Link to agent graph**
   - In Graph Studio, add Tool node
   - Select your published tool
   - Map input variables and capture outputs

### Debugging a Failing Flow

1. **Reproduce the issue**
   - Test with the same input that failed
   - Note exact error message or unexpected behavior

2. **Check execution logs**
   - Go to Observability → Logs
   - Find the session with the error
   - Review timeline: which node failed?

3. **Inspect the failing node**
   - Click the node in the timeline
   - Check inputs, outputs, and error details
   - Verify variable values at that step

4. **Verify configuration**
   - For Agent nodes: Check prompt clarity, RAG sources, tool parameters
   - For Tool nodes: Verify authentication, API keys, parameter mapping
   - For variables: Ensure names match and data types are correct

5. **Fix and test**
   - Update the problematic node or tool
   - Publish changes
   - Re-test with the same input
   - Verify fix in logs

## Common Gotchas

- **Publishing requires Admin/SuperAdmin role**: Developers can edit but not publish to production. Plan approval workflows.
- **API keys in code**: Never hardcode secrets. Use environment variables in DevStudio tools.
- **Variable naming mismatches**: Ensure variable names are consistent between capture and usage points. Typos silently break data flow.
- **RAG sources not indexed**: Attached knowledge sources must be properly indexed. Empty or irrelevant sources won't help agents.
- **Tool parameter mapping**: Verify input/output schemas match between tool definition and agent node configuration.
- **Intents vs Triggers confusion**: Intents are for conversational assistants (user utterances); Triggers are for autonomous assistants (webhooks/cron).
- **Build versioning**: Always increment tool and flow versions when publishing. Old versions in production won't auto-update.
- **Environment isolation**: Dev, UAT, and Prod are separate. Changes in Dev don't affect Prod. Explicitly promote builds.
- **Token limits**: Monitor token usage in Observability. High-volume assistants can exceed quotas quickly.
- **Conditional edge logic**: Conditional edges evaluate LLM-generated decision variables. Ensure the agent's output matches expected decision values.

## Verification Checklist

Before submitting or deploying:

- [ ] **Agent graph tested**: Ran "Test Agent Graph" with sample inputs; execution logs show expected flow
- [ ] **All nodes configured**: Start, Agent, Tools, and End nodes all have required settings
- [ ] **Variables captured**: Input variables are passed correctly; outputs are captured for downstream nodes
- [ ] **Tools authenticated**: API keys and credentials are set in environment variables, not hardcoded
- [ ] **RAG sources attached**: Knowledge bases are linked and indexed (if using RAG)
- [ ] **Intents/Triggers created**: Conversational assistants have intents; Autonomous have triggers
- [ ] **Build created**: Selected correct versions of flows and tools
- [ ] **Environment assigned**: Build is attached to correct environment (Dev/UAT/Prod)
- [ ] **Permissions verified**: User has Admin/SuperAdmin role to publish to production
- [ ] **Logs reviewed**: No errors in execution timeline; decision variables match conditional edge logic
- [ ] **Rollback plan**: Know how to revert to previous build version if needed

## Resources

**Comprehensive navigation**: https://docs.phinite.ai/docs/llms.txt

**Critical documentation pages**:
1. [Graph Studio Overview](https://docs.phinite.ai/docs/graph-studio/overview) — Visual workflow builder and node types
2. [DevStudio Overview](https://docs.phinite.ai/docs/devstudio/overview) — Building and versioning tools
3. [Observability Overview](https://docs.phinite.ai/docs/observability/overview) — Monitoring sessions, logs, and metrics

---

> For additional documentation and navigation, see: https://docs.phinite.ai/docs/llms.txt