# Opulent Docs

> Documentation for the Opulent agent platform

This document contains the full content of all documentation pages for AI consumption.

---

## Opulent Documentation

**URL:** https://opulent-docs.vercel.app/docs
**Description:** Complete documentation for the Opulent agent platform

# Opulent Documentation

Welcome to the official Opulent documentation. Learn how to build, deploy, and scale AI-powered applications with Opulent.

  
  
  

## Core Capabilities

| Capability | Description |
|---|---|
| **Browser Automation** | Cloud and local browser modes — agents operate the web like a person |
| **Application Development** | Architect, build, preview, test, and deploy full applications |
| **Parallel Research** | Multi-agent parallel processing for 100s of tasks at uniform quality |
| **Scheduled Tasks** | Automate recurring work on cron, webhook, or connector event triggers |
| **Workspaces** | Persistent environments with memory and shared context |
| **Ecosystem Connectors** | 250+ pre-built integrations — Stripe, Salesforce, Slack, GitHub |

## Getting Started

1. **Describe what you want** — Tell Opulent what to build in plain English
2. **Review the plan** — Opulent proposes a technical approach
3. **Watch it build** — Live browser preview as the agent works
4. **Deploy** — One command to publish to a real URL

```bash
"Build a modern SaaS landing page with hero, features, and pricing"
```

## Platform Overview

Opulent is a **generally capable agent platform** that transforms AI from a tool that responds to prompts into a system that acts on your behalf:

- **Browser automation** — Agents navigate the web, fill forms, extract data
- **Code execution** — Full filesystem, terminal, and git capabilities
- **Persistent memory** — Context that compounds across sessions
- **Workflow orchestration** — Multi-step pipelines with trigger-based execution
- **250+ integrations** — Connect to any tool via MCP or built-in connectors

---

## Access Control

**URL:** https://opulent-docs.vercel.app/docs/app-builder/access-control
**Description:** Access Control - Opulent documentation

# Access Control

> Add authentication and authorization to your application — login, roles, and protected routes

## What it is

Access Control lets you add user authentication and role-based authorization to any application built with Opulent. Users can sign up, log in, and access content based on their permissions — all configured through natural language.

---

## Quick Start

```
"Add user authentication — email/password signup and login. Protect all dashboard routes."
```

```
"Add login with Google and GitHub OAuth. After login, redirect to /dashboard."
```

```
"Add an admin role. Only users with the admin role can see the /admin section."
```

---

## Authentication Methods

| Method | Description |
|---|---|
| **Email + Password** | Standard signup/login with email verification |
| **Google OAuth** | "Sign in with Google" |
| **GitHub OAuth** | "Sign in with GitHub" — popular for developer tools |
| **Magic Link** | Passwordless — user receives a login link by email |
| **SSO / SAML** | Enterprise single sign-on (Enterprise plan) |

Specify which methods you need:

```
"Add authentication with email/password and Google OAuth. No GitHub."
```

---

## Roles and Permissions

```
"Create three roles: admin, editor, and viewer.
- Admins can create, edit, and delete everything
- Editors can create and edit, but not delete
- Viewers can only read"
```

```
"Add a role check: only users where role = 'pro' can access /export"
```

```
"Add an invite system: admins can invite team members by email"
```

---

## Protecting Routes

```
"All routes under /dashboard require login. Unauthenticated users
are redirected to /login."
```

```
"The /admin section is only accessible to users with the admin role.
Show a 403 page to anyone else."
```

---

## Auth Stack

Opulent uses **Better Auth** by default for new projects — a modern, flexible auth library that supports all common providers and patterns without vendor lock-in.

For projects requiring enterprise auth:
- Clerk (managed auth with full UI components)
- Auth0 (enterprise SSO, MFA, compliance)
- Supabase Auth (when using Supabase as the database)

Specify your preference:
```
"Use Clerk for auth — I want their prebuilt UI components"
```

---

## Common Questions

**Can I add auth to an existing app Opulent built?**
Yes: `"Add email/password authentication to this app"` — Opulent integrates auth into the existing structure.

**Are passwords stored securely?**
Yes. Passwords are hashed with bcrypt or argon2. Opulent never stores plaintext passwords.

**Can users manage their own accounts (change password, delete account)?**
Yes: `"Add an account settings page where users can update their email, change their password, and delete their account"`.

**Does this work with my existing user database?**
If you have an existing users table, specify it: `"Add auth that uses our existing users table in PostgreSQL"`.

---

## Project Analytics

**URL:** https://opulent-docs.vercel.app/docs/app-builder/analytics
**Description:** Project Analytics - Opulent documentation

# Project Analytics

> Understand how users interact with your application — built-in analytics, no third-party tools required

## What it is

Project Analytics gives your application built-in user behavior tracking — page views, user sessions, conversion funnels, feature usage, and custom events — with a dashboard you can see inside Opulent.

---

## Quick Start

```
"Add analytics to this app — track page views and user sessions"
```

```
"Track when users click 'Upgrade' — I want to see the conversion rate
from free to paid in the dashboard"
```

```
"Add a funnel: landing page → signup → onboarding step 1 → activated"
```

---

## What You Can Track

### Automatic Tracking
- Page views (which pages are visited, time on page)
- User sessions (new vs returning, session duration)
- Navigation paths (how users move through the app)

### Custom Events

```
"Track a custom event when:
- User completes onboarding
- User exports a file
- User invites a team member
Include: user ID, plan, and timestamp"
```

### Conversion Funnels

```
"Create a conversion funnel: visit → signup → first project → first export
Show drop-off percentage at each step."
```

---

## Analytics Dashboard

The analytics dashboard is visible at `/admin/analytics` (protected by the admin role) and shows:

| Metric | Description |
|---|---|
| **Daily Active Users (DAU)** | Unique users active each day |
| **Monthly Active Users (MAU)** | Unique users active in the past 30 days |
| **Retention** | % of users who return after day 1, 7, 30 |
| **Top Pages** | Most-visited pages ranked by sessions |
| **Conversion Rate** | % completing your defined funnel |
| **Custom Events** | Any events you've defined |

---

## Third-Party Analytics

Prefer an existing analytics platform?

```
"Add Google Analytics 4 — use this measurement ID: G-XXXXXXXXXX"
"Integrate PostHog for product analytics"
"Add Mixpanel with this project token"
"Add Segment and pipe events to it"
```

Opulent installs the SDK, sets up the initialization, and wires your custom events to the platform.

---

## Common Questions

**Is user data shared with third parties?**
Built-in analytics stores data in your own database. No third-party sharing unless you explicitly add a third-party analytics integration.

**Can I see individual user sessions?**
Yes: `"Add session recording so I can replay individual user journeys"` — Opulent integrates a session replay tool (e.g., LogRocket, Hotjar, PostHog session recording).

**Can the analytics dashboard be exposed to team members, not just admins?**
Yes: `"Allow users with the 'analyst' role to access the analytics dashboard"`.

---

## Built-in AI Capabilities

**URL:** https://opulent-docs.vercel.app/docs/app-builder/built-in-ai
**Description:** Built-in AI Capabilities - Opulent documentation

# Built-in AI Capabilities

> Embed AI features directly into your applications — text generation, image analysis, embeddings, and agents

## What it is

Built-in AI Capabilities let you add AI features to any application you build with Opulent — text generation, image analysis, embeddings for semantic search, and full agent workflows — through natural language instructions.

---

## AI Features You Can Add

### Text Generation

```
"Add a 'Improve Writing' button to each post editor.
When clicked, the current draft is sent to an AI API and the improved
version replaces the draft. Show a diff before accepting."
```

```
"Add an AI-powered search that understands natural language queries,
not just exact keyword matches."
```

### Image Analysis

```
"Allow users to upload a product photo. The app analyzes it and
auto-fills the product title, description, and suggested category."
```

```
"Add a receipt scanner — users upload a photo of a receipt and
the app extracts merchant, date, amount, and category automatically."
```

### Embeddings & Semantic Search

```
"Add semantic search to the knowledge base — users can search with
natural language and find relevant articles even without exact keyword matches."
```

```
"Add a 'Similar items' feature to the product catalog using vector embeddings."
```

### Streaming Responses

```
"The AI writing assistant should stream the response word by word,
like ChatGPT — don't wait for the full response before showing output."
```

### Embedded Agent Workflows

```
"Add a 'Research' button. When clicked, the user's input is sent to
an Opulent agent that researches the topic and streams the result back
into the document editor."
```

---

## AI Models Available

| Use Case | Default Model | Notes |
|---|---|---|
| Text generation | MiniMax M2.5 (Fireworks) | Fast, high-quality |
| Long-form writing | Claude Sonnet 4.6 | Deep reasoning |
| Image analysis | Gemini Flash | Reliable vision |
| Image generation | FAL.ai (Nano Banana Pro) | High quality |
| Embeddings | text-embedding-3-large | Semantic search |

Specify a different model if needed:
```
"Use Claude for the writing assistant — we need the highest quality"
```

---

## AI Usage in Your App

AI usage in your application is billed separately through your Opulent account. Your app users consume AI features via your plan's credits.

For user-facing AI features with high volume, specify rate limits:
```
"Limit the AI assistant to 10 requests per user per day on the free plan,
unlimited on paid plans."
```

---

## Common Questions

**Do I need separate OpenAI or Anthropic API keys?**
No. AI capabilities route through Opulent's managed provider connections. No additional accounts needed.

**Can I use my own API keys?**
Yes: `"Use my OpenAI API key for the text generation feature"` — provide the key and Opulent wires it in.

**Can my app users bring their own API keys?**
Yes: `"Allow users to enter their own OpenAI API key in settings, which overrides the default"`.

**How do I control AI costs in my app?**
Specify per-user limits and usage throttles. Opulent builds the rate limiting logic into the app.

---

## Cloud Infrastructure

**URL:** https://opulent-docs.vercel.app/docs/app-builder/cloud-infrastructure
**Description:** Cloud Infrastructure - Opulent documentation

# Cloud Infrastructure

> Fully managed backend, database, file storage, and deployment — no DevOps required

## What's Included

Every application built with Opulent comes with full-stack infrastructure, completely managed. You describe the features you need; Opulent builds and wires the infrastructure.

| Component | What It Is | Example Uses |
|---|---|---|
| **Backend** | Server-side logic and API routes | User auth, form processing, API integrations, business logic |
| **Database** | Persistent data storage | User profiles, content, records, settings, submissions |
| **File Storage** | Media and document hosting | User uploads, images, PDFs, videos, portfolios |
| **Deployment** | Hosting and delivery | Publishing to a URL, global CDN, auto-scaling |

---

## Backend

Unlike static site builders, Opulent builds full-stack applications with real server-side logic.

```
"Create a user registration system with email/password auth and email verification"
"When a form is submitted, save to the database and send a Slack notification"
"Build an API endpoint that accepts a webhook from the billing provider and updates user subscription status"
```

**Tech options:** Next.js API routes, FastAPI, Express, Hono — specified by you or chosen by Opulent based on the stack.

---

## Database

Applications come with an integrated persistent database. Opulent handles schema design, migrations, and queries.

```
"Build a product catalog with: name, price, description, inventory count, and category"
"Create a blog with posts, authors, tags, and publication dates"
"Add a table that tracks user activity events with timestamps"
```

**Options:** Connected Cortex (default for real-time apps), PostgreSQL, SQLite, Supabase — specify your preference or let Opulent choose.

---

## File Storage

Secure, scalable storage for user uploads and application assets.

```
"Add a profile photo upload feature — store images and display them on the user's profile"
"Create a resources page where we can upload PDFs for users to download"
"Allow users to attach files to their support tickets"
```

---

## Scaling

Infrastructure scales automatically with usage. There are no servers to provision, no capacity planning required, and no downtime during scaling events.

---

## Common Questions

**Do I need a cloud account (AWS, GCP)?**
No. Opulent's managed infrastructure handles everything. If you want to deploy to your own cloud account, specify it during the deployment step.

**Where is the data stored?**
Applications use Opulent's managed infrastructure by default (US region). Enterprise plans support custom regions and data residency requirements.

**What databases can I use?**
Connected Cortex, PostgreSQL, MySQL, SQLite, MongoDB, and Supabase — specify your preference or let Opulent choose based on your app's needs.

**Can I bring my own infrastructure?**
Yes. Specify your preferred hosting targets and database connection strings. Opulent builds to your specifications.

---

## Code Control

**URL:** https://opulent-docs.vercel.app/docs/app-builder/code-control
**Description:** Code Control - Opulent documentation

# Code Control

> Full access to everything Opulent generates — inspect, export, edit, and take your code anywhere

## What it is

Code Control gives you complete visibility and ownership of the code Opulent generates. Every line of code is yours: inspect it in the Code panel, view it in GitHub, download the entire codebase, or edit it locally with your own tools.

There is no proprietary format, no locked-in abstraction. Opulent generates standard code in standard frameworks — Next.js, React, TypeScript — that any developer can read and extend.

---

## Code Panel

The Code panel shows all source files for your current project. Browse directories, open files, and read the generated code.

### What You'll Find

| File/Directory | Contains |
|---|---|
| `app/` or `pages/` | Next.js routes and page components |
| `components/` | Reusable UI components |
| `lib/` or `utils/` | Utility functions and helpers |
| `backend/` or `api/` | Backend functions and API routes |
| `public/` | Static assets |
| `package.json` | Dependencies and scripts |
| `.env.example` | Required environment variables |

---

## Inspecting Generated Code

You can ask Opulent to explain any part of the code:

```
"Explain how the authentication middleware works in this codebase"
"Show me the database schema for the users table"
"What does the useDataQuery hook do in the dashboard page?"
```

---

## Editing Code Directly

For precise changes, edit the code directly:

```
"Change the database query in the analytics page to only count users
created in the last 30 days"
```

Or edit locally, push to GitHub, and Opulent pulls the changes automatically before the next edit session.

---

## Exporting Your Codebase

### Via GitHub

The code is in your GitHub repo at all times. Clone it:

```bash
git clone https://github.com/you/your-project
cd your-project
npm install
npm run dev
```

### Local Download

```
"Export the full codebase as a ZIP file I can download"
```

The complete project is packaged and downloaded — ready to run anywhere.

---

## Running Locally

After cloning:

```bash
# Install dependencies
npm install

# Set up environment variables
cp .env.example .env.local
# Fill in the required values

# Start development server
npm run dev
```

Your application runs locally at `http://localhost:3000`.

---

## What Opulent Never Does

- No proprietary runtime — your code runs on standard Node.js
- No hidden dependencies on Opulent infrastructure (after export)
- No usage restrictions — the generated code is yours with no licensing constraints
- No tracking or callbacks to Opulent in the generated application code

---

## Common Questions

**Can I take the code and host it myself, completely independent of Opulent?**
Yes. The generated code is standard and fully portable. After export, you have no dependency on Opulent unless you choose to use Opulent's AI features within the app.

**Can developers on my team edit the code without using Opulent?**
Yes. It's a standard GitHub repo. Any developer can clone, edit, and push changes.

**What framework and language is used?**
TypeScript + Next.js 15 by default. You can specify a different stack: `"Use Python/FastAPI for the backend"` or `"Build this with SvelteKit"`.

**Can I add Opulent to an existing codebase?**
Yes. Connect your GitHub repo and Opulent works from your existing code, making targeted additions and changes.

---

## Custom Domains

**URL:** https://opulent-docs.vercel.app/docs/app-builder/custom-domains
**Description:** Custom Domains - Opulent documentation

# Custom Domains

> Go live on your own branded URL in minutes

## What it is

Custom Domains lets you publish your Opulent-built application on a professional, branded URL — `app.yourcompany.com`, `dashboard.yourproduct.com`, or any domain you own — instead of the default Opulent subdomain.

---

## Setting Up a Custom Domain

```
"Set up the custom domain: app.yourcompany.com"
```

Opulent will:
1. Configure the domain in your deployment platform (Vercel, Netlify, etc.)
2. Provision an SSL certificate automatically
3. Return the DNS records you need to add

### DNS Records to Add

You'll receive records like:

```
Type: CNAME
Name: app
Value: cname.vercel-dns.com

— or —

Type: A
Name: @
Value: 76.76.21.21
```

Add these in your domain registrar (Namecheap, GoDaddy, Cloudflare, etc.). DNS propagation typically takes 5–30 minutes.

---

## Apex Domains and Subdomains

| Type | Example | Configuration |
|---|---|---|
| **Subdomain** | `app.yourcompany.com` | CNAME record |
| **Apex domain** | `yourcompany.com` | A record + AAAA record |
| **www** | `www.yourcompany.com` | CNAME record |

For apex domains with Cloudflare, use their proxied CNAME (CNAME flattening).

---

## SSL / HTTPS

SSL certificates are provisioned automatically via Let's Encrypt. All traffic is HTTPS by default. HTTP requests are automatically redirected to HTTPS.

---

## Multiple Domains

```
"Add a second domain: www.yourcompany.com pointing to the same app"
"Set up a redirect from yourcompany.com to app.yourcompany.com"
```

---

## Changing Domains

```
"Change the custom domain from app.yourcompany.com to platform.yourcompany.com"
```

The old domain is removed and the new one is configured. Update your DNS records accordingly.

---

## Common Questions

**How long does it take after adding DNS records?**
Usually 5–30 minutes. In rare cases up to 48 hours for full global propagation.

**Can I use a domain registered anywhere?**
Yes — any domain registrar. You only need to be able to add DNS records.

**Is SSL included?**
Yes. Automatic SSL via Let's Encrypt, renewed automatically before expiry.

**What if I'm already using Cloudflare for DNS?**
Use Cloudflare's proxied CNAME or add a CNAME flattening record at the apex. Opulent works with Cloudflare.

---

## Editing and Previewing

**URL:** https://opulent-docs.vercel.app/docs/app-builder/editing-and-previewing
**Description:** Editing and Previewing - Opulent documentation

# Editing and Previewing

> See your application live as it builds — and iterate with natural language

## Live Preview

Opulent's Browser panel shows a live, interactive preview of your application from the moment the first code is written. There is no build step to wait for, no export to run. The preview updates in real time as the agent makes changes.

You interact with the preview exactly as a user would — click buttons, fill forms, navigate between pages.

---

## Making Changes

### Natural Language Edits

Describe what you want changed. The agent understands context from the full conversation history.

```
"Make the sidebar collapsible"
"The font on the hero headline is too small — make it larger"
"Add a loading spinner to the submit button"
"Change the primary color from blue to our brand purple (#6B21A8)"
"The pricing table looks better with a highlighted 'Pro' tier"
```

### Structural Changes

```
"Move the pricing section before the testimonials"
"Add a new 'Integrations' section after the features grid"
"Remove the newsletter signup section — we don't need it"
"Add a sticky header that appears when you scroll down"
```

### Data and Content

```
"Replace the placeholder testimonials with these three real ones: [paste]"
"Update the pricing: Starter $29/mo, Growth $79/mo, Enterprise custom"
"Change the feature descriptions to match our new positioning: [paste]"
```

---

## Preview Modes

| Mode | Description |
|---|---|
| **Desktop** | Full-width preview (default) |
| **Tablet** | ~768px viewport |
| **Mobile** | ~375px viewport |

Switch between modes to check responsive behavior. If something looks wrong on mobile:

```
"The navigation menu doesn't work on mobile — fix the hamburger menu"
"The pricing table is overflowing on mobile — make it stack vertically"
```

---

## Code Panel

While the Browser panel shows the rendered result, the Code panel shows the source files. Use it to:

- Review what was generated
- Understand the component structure
- Copy specific functions or components
- Verify logic before deploying

For developers: all changes made by the agent are committed to GitHub. You can clone the repo, edit locally, and push back — Opulent will pull your changes automatically before the next edit.

---

## Iterating Effectively

**Be specific about what you see:**
- ✅ `"The button in the hero section is too close to the headline — add more spacing"`
- ❌ `"Fix the layout"`

**Reference the preview:**
- ✅ `"The card on the left in the features section has a broken icon"`
- ✅ `"The form on mobile overlaps the footer"`

**Iterate in small steps for visual design:**
- Make one change, review, then continue
- Larger structural changes can be done in one instruction

**Use screenshots for complex issues:**
- Upload a screenshot of what you see and describe what should change
- Opulent's image understanding reads the screenshot and makes targeted fixes

---

## App Builder: Getting Started

**URL:** https://opulent-docs.vercel.app/docs/app-builder/getting-started
**Description:** App Builder: Getting Started - Opulent documentation

# App Builder: Getting Started

> Build full-stack applications through conversation — research, design, code, deploy, and iterate in one place

## The All-in-One Development Workflow

Opulent transforms application development from a fragmented, multi-tool process into a single conversational workflow. Research your users, generate code, see a live preview, deploy to production, and iterate — all without leaving the platform or writing a single line of code yourself.

With Opulent App Builder, you can execute the entire value chain of application development in one place:

- **Research & Plan** — Describe what you want to build; Opulent proposes a technical approach
- **Build** — Agent scaffolds and implements the full application in a persistent workspace
- **Preview** — Live browser preview renders as the app is built
- **Deploy** — One command to publish to a real URL
- **Iterate** — Describe changes in plain English; the preview updates immediately
- **Connect** — Add third-party integrations, payments, auth, and analytics in conversation

---

## Your First App in Minutes

### Step 1: Describe What You Want

Tell Opulent what to build. The more specific, the better the initial result.

```
"Build a modern SaaS landing page with:
- Hero section with a signup form
- Features grid (3 columns)
- Pricing table with 3 tiers
- Customer testimonials section
- Footer with links"
```

```
"Build an internal tool for our ops team to manage vendor contracts.
Fields: vendor name, contract value, start/end dates, owner, status.
Needs login. Deployable to Vercel."
```

### Step 2: Review the Plan

Opulent analyzes your request and presents a development plan: tech stack, file structure, key components, and any assumptions. Review it, request adjustments, then approve.

### Step 3: Watch Opulent Build

Once approved, the agent builds in real time. The Browser panel shows a live, interactive preview from the first line of code. You see the application render and update as each component is added.

### Step 4: Iterate with Natural Language

```
"Change the hero background to a dark gradient"
"Move the testimonials section above the pricing table"
"Add a 'Book a Demo' CTA button to the hero"
"The pricing table looks too cramped — add more spacing"
```

Each instruction is understood in context. Opulent updates the code and the preview refreshes instantly.

### Step 5: Deploy

```
"Deploy this to Vercel and give me the URL"
```

Opulent pushes to GitHub, triggers the deployment, and returns a live URL.

---

## What You Can Build

| Application Type | Example |
|---|---|
| Landing pages | Product launch page, pricing page, waitlist |
| Internal tools | Approval workflows, inventory trackers, team dashboards |
| Full-stack apps | SaaS with auth, database, and payments |
| Data dashboards | Live metrics from your connectors |
| APIs & microservices | Webhook receivers, data transformation services |
| Prototypes | Clickable demos for investor meetings |
| Documentation sites | Product docs, help centers |

---

## No Code Required

You do not need to know how to code to build with Opulent. Every instruction is in plain English. However, if you are a developer:

- All generated code is available in the Code panel
- Code is committed to GitHub automatically — clone and edit locally
- Opulent pulls your changes back and continues from where you left off

---

## Common Questions

**Do I need a hosting account?**
No. Opulent handles deployment to Vercel, Netlify, or Railway as part of the workflow. For custom infrastructure, you can specify your target.

**Who owns the code?**
You do. The code is committed to your GitHub repo. You have full ownership and can take it anywhere.

**Can I import an existing project?**
Yes. Connect your GitHub repo and Opulent works from your existing codebase.

**Can I import a Figma design?**
Yes. See [Import from Figma](./import-from-figma).

---

## GitHub Integration

**URL:** https://opulent-docs.vercel.app/docs/app-builder/github-integration
**Description:** GitHub Integration - Opulent documentation

# GitHub Integration

> Your code, your repo — Opulent builds and commits; you own everything

## What it is

Every application built with Opulent is backed by a GitHub repository. Opulent commits every change automatically, maintaining a complete version history. You can clone the repo, edit locally in any IDE, and push back — Opulent pulls your changes before making the next edit, keeping everything in sync.

---

## How It Works

### Automatic Repository Creation

When you start building, Opulent creates a private GitHub repository in your account:

```
"Build a SaaS dashboard" → Repository: github.com/you/saas-dashboard
```

Or specify a name:
```
"Build this into a repo called 'customer-portal'"
```

### Two-Way Sync

| Direction | When It Happens |
|---|---|
| **Opulent → GitHub** | After every edit session — changes are pushed to the main branch |
| **GitHub → Opulent** | Before every new edit — Opulent pulls latest from main to avoid conflicts |

### Working Locally

Clone the repo and edit in VS Code, Cursor, or any editor:

```bash
git clone https://github.com/you/your-app
cd your-app
npm install && npm run dev
```

Push your changes:

```bash
git add .
git commit -m "Refined the dashboard layout"
git push origin main
```

Return to Opulent — it automatically pulls your changes and continues from there.

---

## GitHub Connector Capabilities

Connecting GitHub also activates the GitHub Connector for the agent:

| Capability | What the Agent Can Do |
|---|---|
| **Code** | Read, write, commit, push, pull |
| **Issues** | Create, view, update, close |
| **Pull Requests** | Create, review, merge, close |
| **Projects** | Interact with GitHub Projects boards |
| **Actions** | Check workflow runs, read logs |

```
"Create a GitHub issue for the navigation bug we just fixed as a note for the team"
"Open a PR for these changes with a description of what was updated"
```

---

## Connecting an Existing Repository

Already have a codebase? Connect it:

1. Go to the chat input → **Attach → Connect Repository**
2. Search for your GitHub repo
3. Opulent clones it and works from your existing code

From that point on, all agent edits commit to your repo.

---

## Disconnecting

Disconnecting GitHub removes the sync but **does not delete your repository**. You retain full ownership and all history. Your Opulent project simply stops committing to it.

---

## Tips

**Use Opulent for structure, your IDE for precision.** Let Opulent scaffold the application and build the complex parts. Then export to GitHub and use your editor for fine-grained styling and business logic. Sync back to Opulent for deployment.

**Don't rename the repo after connecting.** Changing the repository name or owner on GitHub after the connection is established breaks the sync. If needed, disconnect and reconnect with the new repo name.

**Use branches for experiments.** Opulent commits to the main branch by default. Create a branch locally for experiments, then merge when ready.

---

## Common Questions

**Can I use GitLab or Bitbucket instead of GitHub?**
GitHub is the primary supported integration. GitLab and Bitbucket support are on the roadmap.

**What happens to uncommitted local changes when Opulent pulls?**
Opulent pulls from the remote main branch, not your local working copy. Commit and push your local changes before asking Opulent to make edits to the same files.

**Can I have multiple GitHub repos for one Opulent project?**
Each Opulent project maps to one GitHub repository.

**Is the repository public or private?**
Private by default. You can make it public from GitHub settings at any time.

---

## Import from Figma

**URL:** https://opulent-docs.vercel.app/docs/app-builder/import-from-figma
**Description:** Import from Figma - Opulent documentation

# Import from Figma

> Turn your Figma designs into a working application — describe what you want and Opulent builds it

## What it is

Import from Figma converts your Figma designs into a live, functional web application. Share a link to your Figma frame, describe the behavior you want, and Opulent builds the working app — matching your design as closely as possible.

This is not a simple screenshot-to-HTML converter. Opulent reads your design, understands the component structure and layout intent, and produces real, production-quality code with working interactions.

---

## How to Import

### From the Chat Input

1. Copy the Figma frame share link
2. Paste it in the chat with instructions:

```
"Build this design as a working Next.js page: [Figma link]
The email input should validate format. The CTA button opens a confirmation modal."
```

```
"Convert this Figma dashboard design to a working app: [Figma link]
Connect the charts to our Stripe data. The sidebar should be collapsible."
```

### From the Attachment Menu

Click the **Attach** icon → **Import Figma Design** → paste the frame URL → describe behavior.

---

## What Gets Preserved

| Design Element | How It's Handled |
|---|---|
| Layout & spacing | Recreated using Tailwind classes or CSS |
| Typography | Font family, size, weight, and line height matched |
| Colors | Brand colors extracted and applied consistently |
| Components | Buttons, inputs, cards, navbars built as reusable components |
| Images & icons | Embedded or linked from the design |
| Responsive intent | Opulent infers mobile/tablet breakpoints from the design structure |

---

## Adding Behavior

Figma captures the visual design — Opulent adds the logic. Describe the behavior alongside the design import:

```
"Build this landing page from Figma [link]. Make the pricing toggle
switch between monthly and annual with a 20% discount. The signup
button opens an inline form, not a redirect."
```

```
"Convert this dashboard from Figma [link]. The metrics cards should
pull from our Stripe API. The table shows our last 50 transactions.
Add a date range filter."
```

---

## Iterating After Import

Once the initial build is complete, iterate with natural language as with any Opulent project:

```
"The header doesn't match the Figma exactly — the logo should be left-aligned"
"Add a hover state to the feature cards — subtle shadow on hover"
"The mobile layout needs work — the nav collapses at 768px in Figma"
```

---

## Tips

**Share frames, not entire files.** Link to a specific frame or page, not the whole Figma file. Opulent works best with a focused, complete design for one page or component.

**Describe the behavior, not just the design.** The design shows what it looks like. You need to tell Opulent what it does.
- ✅ `"The form submits to our API. On success, show a thank-you message. On error, show the error inline."`
- ❌ Just pasting the link with no behavioral description

**Figma components → React components.** If your Figma uses components consistently, Opulent will create reusable React components that mirror the Figma component structure.

**Check the token for complex designs.** Large Figma files may exceed what Opulent can process in a single pass. Import one page or section at a time.

---

## Common Questions

**Does Opulent access my entire Figma file?**
Opulent reads the specific frame you share. It does not access other frames or files in your Figma workspace.

**What Figma permissions are required?**
The frame must be shared with "Anyone with the link can view" enabled, or you connect your Figma account via Settings → Connectors → Figma.

**How close to pixel-perfect is the output?**
Very close for standard layouts. Complex custom interactions, animations, and highly bespoke designs may require iteration to match exactly.

**Can I import components and a design system, not just pages?**
Yes. Share a Figma frame containing your component library: `"Build React components matching this component library"`.

---

## Notifications

**URL:** https://opulent-docs.vercel.app/docs/app-builder/notifications
**Description:** Notifications - Opulent documentation

# Notifications

> Keep users and teams informed — in-app, email, Slack, and webhook notifications

## What it is

Notifications lets you add real-time alerts and messaging to your application — triggered by user actions, system events, or scheduled conditions.

---

## Notification Types

### Email Notifications

```
"Send a welcome email when a new user signs up"
"Email the admin when a new enterprise plan subscription starts"
"Send a payment failure email 24 hours after a failed charge"
"Email weekly usage summaries to all Pro users every Monday at 9 AM"
```

### In-App Notifications

```
"Add an in-app notification bell to the header. Show notifications for:
team member mentions, task completions, and system alerts."
```

```
"Show a toast notification when an import job completes — success or error"
```

### Slack Notifications

```
"When a new user signs up via enterprise plan, post to #sales with
their company, plan, and MRR contribution"
"Alert #on-call in Slack when error rate exceeds 1% for 5 minutes"
```

### Webhook Notifications

```
"Fire a POST to https://api.yourcompany.com/events when a subscription
starts, upgrades, downgrades, or cancels. Include the user object and event type."
```

---

## Trigger Conditions

| Trigger | Example |
|---|---|
| User action | Signup, login, payment, form submission |
| State change | Status changes from 'pending' to 'active' |
| Threshold | Usage exceeds plan limit |
| Time-based | 3 days before trial ends, weekly summary |
| System event | Error rate spike, deployment success/fail |
| External event | Stripe webhook received, GitHub PR opened |

---

## Email Templates

```
"Design the welcome email with our logo, a personalized greeting,
a 3-step getting-started guide, and a CTA to the dashboard"
```

```
"Create a trial-expiring email that shows: days remaining, their current
usage stats, and a prominent upgrade CTA"
```

Opulent generates the email HTML, registers it as a template, and wires the send trigger automatically.

---

## Common Questions

**What email provider is used?**
Resend by default (reliable, developer-friendly). Can be swapped to SendGrid, Postmark, or any SMTP provider.

**Can I customize email templates after they're created?**
Yes: `"Update the welcome email template — change the headline to..."`.

**Can notifications be batched to avoid flooding users?**
Yes: `"Batch all activity notifications and send a daily digest at 8 AM instead of sending each one immediately"`.

**Can users control their notification preferences?**
Yes: `"Add a notification preferences page where users can toggle each notification type on or off"`.

---

## Payments

**URL:** https://opulent-docs.vercel.app/docs/app-builder/payments
**Description:** Payments - Opulent documentation

# Payments

> Add Agentic Commerce capabilities to any application — subscriptions, one-time charges, bounding policies, and billing portals

## What it is

Opulent integrates an Agentic Commerce Suite into your application through natural language. Subscriptions, one-time charges, free trials, usage-based billing, and customer billing portals — all configured autonomously without manual payment logic. Leverage Shared Payment Tokens (SPTs) securely scoped to agents so they can execute financial transactions within enterprise boundaries.

---

## Quick Start

```
"Add commerce functionality with 3 subscription tiers: Starter ($29/mo), Growth ($79/mo), Enterprise (custom)"
```

```
"Add a one-time payment of $299 for our course. After payment, unlock the /course section."
```

```
"Add a 14-day free trial for the Growth plan. Require a credit card to start."
```

---

## Payment Types

### Subscription Plans

```
"Create monthly and annual subscription plans:
- Starter: $29/mo or $290/yr (2 months free)
- Pro: $79/mo or $790/yr
- Enterprise: contact sales

Annual plans should show the per-month price with 'save X%' callout."
```

### One-Time Payments

```
"Add a $199 one-time payment for lifetime access. After payment, set
user.plan = 'lifetime' in the database."
```

### Usage-Based Billing

```
"Implement usage-based billing — charge $0.01 per API call over 1,000/month.
Show current usage in the account dashboard."
```

### Free Trials

```
"Add a 14-day free trial for Pro. No credit card required.
Send an email reminder at day 10 and day 13.
Auto-downgrade to Free tier if no payment after trial ends."
```

---

## Customer Billing Portal

```
"Add a billing portal page where users can:
- View their current plan
- Upgrade or downgrade
- Update payment method
- View and download invoices
- Cancel their subscription"
```

Opulent utilizes hosted Agentic Commerce Protocols (ACP) for all billing management — no custom UI to build or maintain.

---

## Webhooks

Commerce protocol events are handled automatically:

| Event | What Happens |
|---|---|
| `checkout.session.completed` | User's plan is updated in the database |
| `customer.subscription.deleted` | Plan downgraded, access removed |
| `invoice.payment_failed` | Email sent, grace period begins |
| `customer.subscription.updated` | Plan change reflected immediately |

```
"When a subscription is cancelled, downgrade the user to the free tier
and send a win-back email after 7 days."
```

---

## Tips

**Test with test mode first.** Opulent provisions test environment keys by default. Switch to live keys when ready to go live:
```
"Switch to live mode for production"
```

**Specify exactly what changes after payment.** The agent needs to know what unlocks:
- ✅ `"After payment, set user.subscriptionTier = 'pro' and redirect to /dashboard"`
- ❌ `"Add payments"` (what should change?)

---

## Common Questions

**Do I need a commerce provider account?**
Yes. Connect your payment processing account via Settings → Connectors → Payments, or provide your API keys when prompted.

**Are commerce API keys and SPTs stored securely?**
Yes. Keys are stored as environment variables in your deployment platform, not in the source code.

**Can I add payments to an existing app?**
Yes: `"Add subscription billing to this app"`.

**What happens during a failed payment?**
By default: a grace period email is sent, and access is suspended after the configurable grace period (default: 3 days).

---

## Publishing

**URL:** https://opulent-docs.vercel.app/docs/app-builder/publishing
**Description:** Publishing - Opulent documentation

# Publishing

> Deploy your application to production with a single instruction

## Deploying Your App

When you're ready to go live:

```
"Deploy this to Vercel and give me the URL"
"Deploy to production"
"Push to GitHub and trigger a deployment"
```

Opulent handles the entire process:
1. Builds the production bundle
2. Pushes code to your GitHub repository
3. Triggers the deployment to your configured host
4. Returns the live URL

---

## Deployment Targets

| Platform | Notes |
|---|---|
| **Vercel** | Recommended for Next.js apps. Zero-config. Global CDN. |
| **Netlify** | Great for static sites and JAMstack apps |
| **Railway** | Full-stack apps with a database |
| **Fly.io** | Containerized apps, global edge deployment |
| **Render** | Full-stack with background workers and databases |
| **Custom** | Specify your own server: `"Deploy to our EC2 instance at [IP]"` |

---

## Preview vs. Production Deployments

**Preview deployment:**
```
"Deploy to a preview URL so I can share it for review"
```
Gets a temporary URL for stakeholder review without replacing the production deployment.

**Production deployment:**
```
"Deploy to production"
```
Updates the live production URL.

---

## Environment Variables

Before deploying, specify your secrets:

```
"Set the following environment variables for the Vercel deployment:
DATABASE_URL, STRIPE_SECRET_KEY, NEXT_PUBLIC_APP_URL"
```

Opulent configures these in your deployment platform — they are never stored in the repository.

---

## Custom Domains

```
"Set up custom domain: app.yourcompany.com"
```

Opulent configures the domain in your deployment platform and provides DNS records to add. See [Custom Domains](./custom-domains).

---

## Redeployment

After making changes:

```
"Redeploy with the latest changes"
```

Or changes can be deployed automatically after each edit session — configure this in **Settings → App Builder → Auto-deploy**.

---

## Checking Deployment Status

```
"What's the status of the current deployment?"
"Did the last deployment succeed?"
```

Opulent queries the deployment platform and reports build logs, status, and any errors.

---

## Search Engine Optimization

**URL:** https://opulent-docs.vercel.app/docs/app-builder/seo
**Description:** Search Engine Optimization - Opulent documentation

# Search Engine Optimization

> Built-in SEO for every application — metadata, sitemaps, structured data, and performance

## What it is

SEO capabilities are built into every application Opulent builds. Meta tags, Open Graph, structured data, sitemaps, and performance optimizations are configured automatically — and you can refine them through natural language.

---

## What's Configured Automatically

| Feature | What Opulent Does |
|---|---|
| **Meta tags** | `<title>` and `<meta description>` for every page |
| **Open Graph** | Social sharing cards (Facebook, LinkedIn) |
| **Twitter Cards** | Twitter-optimized sharing previews |
| **Canonical URLs** | Prevents duplicate content penalties |
| **Sitemap** | Auto-generated `sitemap.xml` |
| **robots.txt** | Configured appropriately for public/private routes |
| **Structured Data** | JSON-LD schema for rich results where applicable |
| **Performance** | Image optimization, lazy loading, critical CSS |

---

## Customizing SEO

### Per-Page Metadata

```
"Set the SEO title and description for the landing page:
Title: 'Opulent — AI Agent Platform for Enterprise Teams'
Description: 'Automate research, analysis, and workflows with an AI agent that connects to your entire stack.'"
```

```
"Add dynamic SEO metadata to each blog post — use the post title and excerpt"
```

### Structured Data

```
"Add FAQ structured data to the pricing page — use our FAQ section content"
"Add Product structured data with pricing information"
"Add Organization schema with our company details"
```

### Sitemap Priority

```
"Set sitemap priorities: homepage = 1.0, product pages = 0.8,
blog posts = 0.6, legal pages = 0.3"
```

---

## Performance (Core Web Vitals)

Google uses Core Web Vitals (LCP, FID, CLS) as ranking signals. Opulent-built applications optimize for these automatically:

- **Images** are served in WebP/AVIF format with responsive sizes
- **Fonts** are subset and loaded with `font-display: swap`
- **JavaScript** is code-split by route
- **Critical CSS** is inlined for above-the-fold content

To audit performance:
```
"Run a Lighthouse audit on the landing page and fix any issues"
```

---

## Common Questions

**Is SEO handled differently for dynamic vs. static pages?**
Yes. Static pages use build-time metadata. Dynamic pages (like blog posts) use server-side metadata generation so each page has unique, crawlable content.

**Can I add a blog for SEO?**
Yes: `"Add a blog with a CMS so I can write and publish SEO-optimized posts. Each post should have its own meta title, description, and structured data."`.

**Do I need a sitemap plugin?**
No. The sitemap is auto-generated and submitted to Google Search Console as part of deployment.

---

## Third-Party Integrations

**URL:** https://opulent-docs.vercel.app/docs/app-builder/third-party-integrations
**Description:** Third-Party Integrations - Opulent documentation

# Third-Party Integrations

> Connect Stripe, Google Maps, external APIs, and any REST service — secure keys, natural language setup

## What it is

Third-Party Integrations lets you add external services to your application through natural language. Connect a payment processor, a mapping service, an external REST API, or any third-party tool — Opulent installs the SDK, writes the integration code, and secures the credentials.

---

## Common Integrations

### Payments
```
"Integrate Stripe — monthly subscriptions with $29 Starter and $79 Pro tiers"
"Add PayPal as an alternative payment option"
```
→ See [Payments](./payments) for the full guide.

### Maps & Location
```
"Add a Google Maps component showing our office locations"
"Add an address autocomplete field using Google Places API"
"Show a map of all our customer locations on the analytics dashboard"
```

### Communication
```
"Integrate Twilio to send SMS verification codes on signup"
"Add a Sendgrid integration for transactional emails"
"Connect Intercom for in-app customer support chat"
```

### AI Services
```
"Add OpenAI for a writing assistant feature"
"Integrate ElevenLabs for AI voice narration"
"Add Replicate for image generation"
```

### Analytics
```
"Add Mixpanel for product analytics"
"Integrate Segment and pipe events to it"
"Add Hotjar for session recording"
```

### Data & Search
```
"Add Algolia for instant search across our product catalog"
"Integrate Clearbit to enrich new user signups with company data"
"Connect Fixer.io for real-time currency conversion"
```

---

## How It Works

1. You describe the integration you need
2. Opulent installs the appropriate SDK via npm/pip
3. Writes the integration code (API calls, error handling, types)
4. Stores credentials as environment variables — never in source code
5. Tests the integration with a sample call

---

## Securing API Keys

All third-party API keys are stored as environment variables:

```
STRIPE_SECRET_KEY=sk_live_...
GOOGLE_MAPS_API_KEY=AIzaSy...
SENDGRID_API_KEY=SG....
```

They are:
- Never committed to the repository (`.env` is in `.gitignore`)
- Configured in your deployment platform's secure environment variable storage
- Never exposed in client-side code (server-side only where required)

---

## Any REST API

Opulent can integrate any REST API — not just pre-built connectors:

```
"Integrate with this REST API to fetch our inventory:
GET https://api.internal.acme.com/inventory
Auth: Bearer token stored in INVENTORY_API_KEY env var
Returns: array of {sku, name, quantity, location}
Show results in a table on /admin/inventory"
```

Provide the API documentation or a sample request/response and Opulent writes the full integration.

---

## Common Questions

**Can I use APIs that require OAuth on behalf of users?**
Yes: `"Add Google Calendar OAuth — users connect their own calendar and we show their events in the app"`.

**What if the API I need isn't well-documented?**
Paste a sample request/response and describe what you need. Opulent infers the integration from examples.

**Are there rate limits I need to handle?**
Yes, and Opulent handles them: `"The weather API limits to 60 requests/minute — add retry logic with exponential backoff"`.

---

## Usage and Pricing

**URL:** https://opulent-docs.vercel.app/docs/app-builder/usage-and-pricing
**Description:** Usage and Pricing - Opulent documentation

# Usage and Pricing

> How Opulent billing works for platform usage and for applications you build

## Opulent Platform Usage

Opulent uses a credit-based system. Credits are consumed when the agent executes tasks — the amount depends on task complexity, tools used, and model selection.

### What Consumes Credits

| Activity | Credit Usage |
|---|---|
| Research and analysis tasks | Based on steps and tools used |
| Code generation and iteration | Per agent step |
| Browser automation | Per browsing session |
| Image generation | Per image |
| Video generation | Per clip |
| Parallel Research subagents | Per subagent deployed |
| Scheduled task execution | Same as manual execution |
| API calls | Same as web UI execution |

### Plans

| Plan | Credits | Best For |
|---|---|---|
| **Starter** | 500 credits/mo | Personal projects, light usage |
| **Growth** | 2,500 credits/mo | Professionals, daily use |
| **Team** | 10,000 credits/mo | Small teams |
| **Enterprise** | Custom | High-volume, compliance requirements |

Unused credits do not roll over. Additional credits can be purchased à la carte.

---

## Applications You Build

Applications built with Opulent and deployed to production have separate billing:

### Hosting

Applications are deployed to Vercel, Netlify, Railway, or your own infrastructure. Hosting costs are billed directly by those platforms under your accounts. Opulent does not add a markup on hosting.

### Database

If using Opulent's managed Managed Context Engine deployment, database usage is covered under your Opulent plan up to plan limits. PostgreSQL and other databases on external providers are billed by those providers directly.

### User-Facing AI Features

If your application has AI features that end users consume (a writing assistant, AI search, etc.), those calls consume your Opulent plan's credits. For high-volume user-facing AI, use your own API keys to route directly:

```
"Use my OpenAI API key for the writing assistant — bill my account directly, not through Opulent credits"
```

---

## Estimating Costs

### Research Task
- Simple web search + summary: ~5 credits
- Deep research with 10+ sources: ~30–60 credits
- Parallel Research of 50 items: ~200–500 credits (scales with item count)

### Development Task
- Simple component addition: ~10 credits
- Full-page build: ~50–100 credits
- Full application scaffold: ~200–500 credits

### Scheduled Tasks
- Daily news digest: ~5–10 credits/execution
- Weekly competitive report: ~50–100 credits/execution

---

## Monitoring Usage

View your current credit balance and recent usage from **Settings → Usage**.

Receive alerts when approaching your plan limit:
- 75% usage: email notification
- 90% usage: email + Slack notification (if connected)
- 100% usage: tasks pause until the next billing cycle or credits are added

---

## Common Questions

**Do unused credits roll over?**
No. Credits reset at the start of each billing cycle.

**Can I buy additional credits mid-cycle?**
Yes. Purchase credits from Settings → Usage → Add Credits.

**What happens if I run out of credits?**
Active tasks pause. Scheduled tasks are skipped until credits are available. You receive a notification and can purchase credits to resume immediately.

**Is there a free plan?**
Yes. New accounts receive 100 free credits to explore the platform. No credit card required for the free plan.

**How are Enterprise plan credits priced?**
Enterprise pricing is custom, based on volume and commitment. Contact sales at sales@opulentia.ai.

---

## Agent Skills

**URL:** https://opulent-docs.vercel.app/docs/features/agent-skills
**Description:** Agent Skills - Opulent documentation

# Agent Skills

> Extend any agent with specialized, reusable capabilities — install from the library or build your own

## What are Agent Skills?

Agent Skills are modular capability packages that extend what an Opulent agent knows and can do. A skill gives the agent specialized instructions, tool access, and knowledge for a specific domain or workflow — installed once, available in every task.

Skills are how you move from a general-purpose agent to one that's an expert in your specific domain: your company's tech stack, your industry's compliance requirements, your team's workflow conventions.

---

## How Skills Work

When a skill is active in an agent's workspace, the agent automatically:
- Applies the skill's specialized knowledge in relevant tasks
- Uses the tools and patterns defined by the skill
- Follows the workflow conventions the skill specifies

You don't need to invoke a skill explicitly — the agent determines when a task is relevant to an active skill and applies it.

---

## Built-in Skills

Opulent ships with a library of pre-built skills across common domains:

### Development
| Skill | What It Does |
|---|---|
| **Code Review** | Reviews code for correctness, security, performance, and style per language best practices |
| **Commit & PR** | Writes clear commit messages and PR descriptions from diff context |
| **Debugging** | Systematic root cause analysis and fix generation |
| **Test Writing** | Generates comprehensive test suites for any codebase |
| **API Documentation** | Produces OpenAPI specs and human-readable API docs from code |

### Research & Analysis
| Skill | What It Does |
|---|---|
| **Deep Research** | Multi-source research with citation and synthesis |
| **Competitive Intelligence** | Structured competitor analysis: features, pricing, positioning |
| **Financial Analysis** | Financial statement reading, ratio analysis, and modeling |
| **Literature Review** | Academic paper synthesis and citation network analysis |

### Content & Communication
| Skill | What It Does |
|---|---|
| **Executive Writing** | Board-level documents, memos, and reports |
| **Sales Copywriting** | Outbound email sequences, landing page copy, and pitch decks |
| **Technical Writing** | SOPs, documentation, and API guides |
| **SEO Content** | Keyword-optimized content with metadata |

### Business Operations
| Skill | What It Does |
|---|---|
| **CRM Operations** | Salesforce and HubSpot data entry, enrichment, and reporting |
| **Financial Operations** | Invoice processing, expense categorization, and P&L analysis |
| **Project Management** | Sprint planning, status reporting, and risk tracking |
| **HR Operations** | Resume screening, job description writing, and onboarding docs |

---

## Installing a Skill

### From the Skills Library

1. Open your workspace or agent config
2. Go to **Agent Builder → Skills**
3. Browse or search the library
4. Click **Install** on any skill
5. The skill is active for all tasks in that workspace

### Per-Task Skill Activation

```
"Use the Competitive Intelligence skill to analyze Salesforce as a competitor"
```

```
"Apply the Code Review skill to this PR diff"
```

---

## Building Custom Skills

Create skills tailored to your team's specific workflows, terminology, and conventions.

### What a Custom Skill Contains

- **Name and description** — Used to match the skill to relevant tasks
- **Instructions** — What the agent should know and how it should behave
- **Tools** — Which connectors and capabilities to activate
- **Knowledge files** — Documents, specs, or guides the agent should reference

### Creating a Custom Skill

1. Go to **Agent Builder → Skills → Create New Skill**
2. Give it a name: `"Acme Corp Deal Reviews"`
3. Write the instructions:

```
When reviewing a sales deal or prospect, always:
1. Check if the company is already in Salesforce before creating a new record
2. Use our ICP criteria: B2B SaaS, 50-500 employees, US-based
3. Rate opportunities using our MEDDIC framework
4. Format deal notes as: Problem → Champion → Decision criteria → Timeline → Budget
5. Reference our case studies from the knowledge base when relevant
```

4. Upload knowledge files (your playbook, pricing guide, case study library)
5. Specify tools: Salesforce connector, web research, document creation
6. Save and install on the relevant workspace

---

## Skills vs. Slash Commands

| | Skills | Slash Commands |
|---|---|---|
| Activation | Automatic when relevant | Explicit — you type the command |
| Scope | Persistent, always available in workspace | Per-message prompt prefix |
| Use case | Domain expertise, workflow conventions | Directing behavior for one task |
| Best for | Your company's specific patterns | Quick behavioral modifiers |

Use skills for things you always want the agent to know. Use slash commands for things you want to apply to a specific task.

---

## Skills in the Agent Builder

When configuring an agent in Agent Builder:

- Install skills from the library for the agent's domain
- Write custom skills for your organization's specific needs
- Combine multiple skills: an agent can be a Code Reviewer + Technical Writer + GitHub Operator simultaneously
- Preview how the agent behaves with each skill active before deploying

---

## Tips

**One skill per domain.** Build separate skills for separate concerns — don't combine your code review conventions and your sales playbook into a single skill.

**Keep instructions precise.** Skills work best with specific, actionable instructions rather than general guidance.

**Reference your actual docs.** Upload your real SOPs, playbooks, and style guides as knowledge files rather than trying to summarize them in the instructions.

**Test with representative tasks.** After creating a skill, run 3–5 representative tasks to verify the agent applies it correctly before deploying widely.

---

## Common Questions

**Can I share custom skills with my team?**
Yes. Skills created in a workspace are available to all workspace members.

**Can a skill override a built-in agent behavior?**
Skills add to and refine agent behavior — they don't override core safety or accuracy constraints.

**How many skills can one agent have?**
No hard limit. In practice, 3–5 focused skills produce better results than 15 broad ones.

**Can I update a skill after installing it?**
Yes. Edits to a skill take effect on the next task the agent runs.

**Are skills visible to end users?**
Skills are configuration — they influence the agent's behavior but are not surfaced in the user-facing chat interface.

---

## AI Drive

**URL:** https://opulent-docs.vercel.app/docs/features/ai-drive
**Description:** AI Drive - Opulent documentation

# AI Drive

> Your intelligent knowledge base — documents that understand themselves

## What is AI Drive?

AI Drive is Opulent's document intelligence system. It doesn't just store your files — it understands them. Upload any document and AI Drive automatically extracts meaning, creates searchable embeddings, and enables retrieval-augmented queries across your entire knowledge base.

Think of it as giving your documents a memory and a voice.

---

## How It Works

### 1. Ingestion

Drop files into AI Drive and the system automatically:
- Parses content from PDFs, Word docs, text files, and more
- Extracts structured data from tables and forms
- Handles multi-page documents and large files
- Organizes content into logical chunks for retrieval

### 2. Embedding Generation

Every document is converted into a vector embedding — a numerical representation of its meaning. This enables:
- Semantic search (find "financial reports" even if the file says "Q4 earnings")
- Cross-document reasoning
- Similarity comparisons between documents

### 3. Retrieval Pipeline

When you query your knowledge base:
1. Your query is embedded using the same model
2. The system finds the most semantically similar chunks
3. Results are ranked by relevance and freshness
4. The agent uses this context to answer your question

This is retrieval-augmented generation (RAG) — combining your documents with AI reasoning.

---

## Capabilities

### Multi-Modal Understanding

AI Drive processes:
- Text documents and PDFs
- Spreadsheets and tables
- Presentations
- Code repositories
- Meeting transcripts

### Continuous Learning

As you add more documents:
- The knowledge graph grows more powerful
- Cross-references emerge automatically
- The system becomes better at answering complex queries

### Source Attribution

Every answer includes citations:
- Which documents were used
- Which sections are relevant
- Confidence scores for each claim

---

## Use Cases

### Internal Knowledge Base

Upload company docs, policies, and specs. Team members ask questions and get answers backed by source material.

### Customer Support

Feed AI Drive your product docs, FAQs, and support tickets. Agents answer customer questions with verified information.

### Research Repository

Upload papers, articles, and findings. Query across your entire library to surface relevant insights.

### Contract Analysis

Upload contracts and legal documents. Ask questions like "what are the payment terms?" and get answers with section citations.

---

## Integration

AI Drive connects with:
- Your file storage (local, S3, Google Drive, Dropbox)
- Opulent's agent system for context-aware responses
- Webhooks for automated document processing
- APIs for programmatic ingestion and querying

---

## Application Development

**URL:** https://opulent-docs.vercel.app/docs/features/application-development
**Description:** Application Development - Opulent documentation

# Application Development

> From idea to deployed application — architect, build, test, preview, and ship entirely inside Opulent

## What it is

Opulent is a full-stack development environment. The agent doesn't just write code snippets — it architects complete applications, builds them in a persistent sandboxed workspace, runs a live browser preview as it works, writes and runs tests, commits to GitHub, and deploys to production. You see the application render in the Browser panel as it's being built.

---

## Quick Start

### Build an Internal Tool

```
"Build a web dashboard that shows our MRR, churn, and top customers
from Stripe. Next.js, Tailwind, dark theme. I want to deploy it to Vercel."
```

### Build a Full Application

```
"Build a B2B SaaS onboarding tracker. Users can:
- Create customer accounts
- Assign onboarding tasks with due dates
- Track completion percentage per account
- Send automated email reminders

Use Next.js, Convex for the database, Better Auth for login. Deploy-ready."
```

### Prototype from Description

```
"Build a working prototype of our new pricing page — 3 tiers, feature
comparison table, FAQ accordion, and a CTA that opens a demo booking modal.
Deploy to a shareable Vercel URL."
```

---

## How It Works

### 1. Architect

The agent analyzes your requirements, proposes a technical approach — stack, data model, component structure, API design — and presents it for approval before writing any code.

```
"Before building, lay out the technical architecture for this application:
recommended stack, database schema, key components, and deployment approach."
```

### 2. Build

The agent creates the project in a dedicated Daytona sandbox:
- Scaffolds the application
- Creates folder structure and config
- Implements components, API routes, and business logic
- Installs dependencies
- Commits each change to a feature branch

### 3. Live Preview

As the agent builds, a live browser preview opens in the Browser workbench panel. You see the actual application rendering — not a mockup — updating in real time as files change.

```
"Show me the current state of the app in the preview"
```

### 4. Iterate Conversationally

Describe changes directly — the agent updates the code and the preview refreshes:

```
"Make the sidebar collapsible"
"Add a loading skeleton to the data table"
"Change the primary button color to match our brand — #1a1aff"
"Add pagination to the customer list — 20 rows per page"
```

### 5. Test

```
"Write integration tests for the authentication flow and the
Stripe webhook handler. Run them and show me the results."
```

The agent writes tests, executes them in the sandbox, and reports results. If tests fail, the agent fixes the code until they pass.

### 6. Deploy

```
"Deploy to Vercel. Push to the main branch and give me the production URL."
```

The agent pushes the final code to GitHub, triggers a Vercel deployment, and returns the live URL.

---

## Tech Stack Support

| Layer | Supported Technologies |
|---|---|
| **Frontend** | Next.js, React, Vue, Svelte, Astro, plain HTML/CSS/JS |
| **Styling** | Tailwind CSS, shadcn/ui, CSS Modules, styled-components |
| **Backend** | Next.js API routes, FastAPI, Express, Django, Flask, Hono |
| **Database** | Convex, PostgreSQL, MySQL, SQLite, MongoDB, Supabase |
| **Auth** | Better Auth, Clerk, Supabase Auth, NextAuth |
| **Payments** | Stripe (subscriptions, one-time, webhooks) |
| **Deployment** | Vercel, Netlify, Railway, Fly.io, Render |
| **Version Control** | GitHub — branch, commit, PR, merge |
| **Package Managers** | npm, pnpm, yarn, pip, cargo |

---

## Common Use Cases

### Internal Tools
Operations and finance teams get custom dashboards, approval workflows, and data entry forms in hours — without waiting in the engineering backlog.

```
"Build an internal tool where our ops team can view and approve
expense reports submitted via Airtable. Requires login. Deploy to Vercel."
```

### Prototypes
Founders and PMs demo working products to investors and customers before engineering has written a line of code.

```
"Build a working demo of our AI writing assistant. GPT-4 integration,
live streaming responses, dark theme, mobile-responsive."
```

### API Integrations
Connect two SaaS tools that don't talk to each other — the agent writes and deploys the integration.

```
"Build a webhook receiver that listens for new Stripe subscriptions,
looks up the customer in HubSpot, and creates an onboarding deal in the pipeline."
```

### Data Applications
Analysts get a working web app to explore and visualize datasets — instead of static spreadsheets.

```
"Build a data explorer for our Postgres database. Let users query any table,
filter by date range, and export results as CSV. Read-only access."
```

### Microservices
Build lightweight backend services without DevOps overhead.

```
"Build a PDF generation API — accepts HTML input, returns a rendered PDF.
Deploy to Railway, return the endpoint URL."
```

---

## The Full Stack in One Workflow

```
"Build a complete customer feedback portal:
1. Public-facing form: name, email, feedback, rating
2. Stores submissions in Convex
3. Admin dashboard: view all feedback, filter by rating, mark as reviewed
4. Auto-email notification to support@company.com on new submission
5. Deploy to Vercel, share the live URL"
```

The agent handles every layer — frontend, database, auth, email, deployment — in a single connected workflow.

---

## Tips

**Be specific about the stack upfront.** Specifying your preferred technologies prevents the agent from guessing:
- ✅ `"Next.js 15, Tailwind, Convex, deploy to Vercel"`
- ❌ `"Build me a web app"`

**Use the preview to guide iteration.** Watch the live preview and describe what to change as you see it — faster than writing detailed specs.

**Ask for architecture before building complex apps.** For anything beyond a simple CRUD app: `"Before building, propose the architecture and get my approval"`.

**Let the agent write the tests.** After the build is done: `"Write tests for the critical paths and run them"`.

**Deploy early, deploy often.** Even for prototypes: `"Deploy the current state to a preview URL"` so stakeholders can see real progress.

---

## Common Questions

**Does the code live in my GitHub?**
Yes. The agent commits to a GitHub repo. You own the code completely.

**Can I open the project in my local IDE?**
Yes. Clone the repo the agent created and continue in VS Code, Cursor, or any editor.

**What if I already have an existing codebase?**
Connect your GitHub repo in the chat input. The agent clones it and works in that context.

**Can the agent deploy to my existing infrastructure?**
Yes, with access credentials: `"Deploy to our AWS EC2 instance at this IP"` or `"Push to our existing Railway project"`.

**How are secrets and environment variables handled?**
The agent creates a `.env.example` with all required variables and guides you through setting them in your deployment environment.

---

## Automations

**URL:** https://opulent-docs.vercel.app/docs/features/automations
**Description:** Automations - Opulent documentation

# Automations

> Scheduled workflows that run on autopilot — so you set it once and forget it

## What are Automations?

Automations let you define recurring workflows that execute automatically on a schedule or trigger. Instead of manually invoking agents for repetitive tasks, you configure the workflow once and let Opulent handle the rest.

---

## Workflows vs. Tasks

### Tasks

A task is a one-time agent execution — you prompt, the agent acts, task completes. Ideal for ad-hoc work.

### Workflows

A workflow is a reusable sequence of agent actions, conditional logic, and integrations. You define the flow once, then trigger it on demand or on a schedule.

### Automations

An automation is a workflow configured to run automatically:
- **Scheduled** — Daily, weekly, or custom cron expressions
- **Trigger-based** — When specific events occur (email received, file uploaded, webhook fired)
- **Recursive** — Tasks that feed their output back as input for the next iteration

---

## How Automations Work

### 1. Build the Workflow

Create a workflow using the visual builder or YAML. Define:
- Input parameters
- Agent actions in sequence
- Conditional branches (if X, do Y)
- Integration touchpoints

### 2. Set the Schedule

Choose when your automation runs:
- Fixed intervals (every hour, daily at 9am)
- Complex schedules (first Monday of each month)
- Event triggers (webhook, email, file drop)

### 3. Configure Notifications

Get notified on completion, failure, or when human input is needed. Results can be delivered via:
- Email
- Slack/Discord
- Webhook to your system

---

## Example Automations

### Daily Research Digest

Every morning, your agent:
1. Searches for updates on your tracked topics
2. Summarizes findings into a brief
3. Emails the digest to your inbox

### Weekly Report Generation

Every Friday, the agent:
1. Pulls data from your connected tools
2. Generates charts and insights
3. Compiles into a PDF report
4. Posts to your team workspace

### Continuous Data Processing

When new files arrive in a folder:
1. Agent processes the file (extract, transform, analyze)
2. Results stored in your database
3. Summary sent to relevant team members

---

## Monitoring & Logs

Every automation execution is logged with:
- Full input/output at each step
- Execution duration and costs
- Error details and retry attempts
- Ability to replay or modify mid-flow

---

## Autos Continuation

**URL:** https://opulent-docs.vercel.app/docs/features/autos-continuation
**Description:** Autos Continuation - Opulent documentation

# Autos Continuation

> Seamlessly resume long-running, complex tasks across sessions without hitting context limits

## What is Autos Continuation?

Autos Continuation is Opulent's approach to durable execution for long-horizon agent workflows. When an agent is assigned a task that takes hours or involves massive amounts of data processing, standard LLM context windows inevitably fill up, causing the agent to degrade in quality or fail entirely. 

Autos Continuation solves this by allowing the agent to continuously checkpoint its progress, prune its active context window, and seamlessly "continue as new" without losing track of the overarching objective.

---

## The Long-Horizon Problem

Traditional AI agents struggle with tasks that span long durations or process large volumes of information:
- **Context Bloat:** As the agent reads pages, executes code, and generates output, the context window fills up.
- **Degradation:** Approaching the context limit, agents start hallucinating, forgetting initial instructions, or getting stuck in loops.
- **Fragility:** If a step fails on hour 3 of a 4-hour task, traditional agents lose all their progress.

---

## How Autos Continuation Works

Opulent's orchestration layer leverages durable execution primitives to manage agent state autonomously:

### 1. State Checkpointing
As the agent makes progress, it periodically commits its state—what it has learned, what steps are complete, and what remains to be done—into the workspace's persistent environment.

### 2. Context Pruning (Continue-As-New)
Before the context window reaches a critical threshold, the agent performs a "continue-as-new" operation. It summarizes its recent activities, preserves the core objective, and spawns a fresh session. The new session picks up exactly where the old one left off, but with a clean, optimized context window.

### 3. Resilient Resumption
Because the workflow state is durable, if an integration API goes down or a node fails, the workflow simply pauses and retries. Interruptions no longer mean starting over from scratch.

---

## Real-World Use Cases

### Comprehensive Code Audits
```
"Review this entire 50,000-line repository for security vulnerabilities.
Document each issue found and submit a pull request with fixes."
```
*Autos Continuation allows the agent to process directory by directory, rolling over its context while maintaining a master list of discovered vulnerabilities.*

### Massive Data Migration & Extraction
```
"Scrape these 500 documentation pages, extract the API schemas, and translate
them into our custom OpenAPI format."
```
*Instead of failing at page 40 when the context fills, the agent checkpoints after every 20 pages, continuing as new until all 500 are processed.*

### Unbounded Autonomous Operation
Set an agent on a continuous monitoring task. It can run indefinitely, checkpointing its state daily or weekly, without ever hitting a hard context limit or memory exhaustion.

---

## Benefits of Durable Execution

| Feature | Impact |
| --- | --- |
| **Infinite Horizon** | Agents can run for days or weeks on a single unified objective. |
| **Deterministic Replay** | You can rewind an agent's execution history to see exactly why it made a decision hours ago. |
| **Zero Progress Loss** | Network failures or timeouts pause the agent instead of killing the task completely. |
| **Cost Efficiency** | By keeping the active context window small and focused, inference costs are drastically reduced compared to sending massive token sequences on every turn. |

---

## Monitoring Autos Continuation

When an agent triggers a continuation, you will see a status update in the workflow UI indicating a "Checkpoint & Resume" event. This is normal behavior and indicates the system is actively managing memory to ensure top-tier performance on your long-running task.

---

## Browser Automation

**URL:** https://opulent-docs.vercel.app/docs/features/browser-automation
**Description:** Browser Automation - Opulent documentation

# Browser Automation

> Two browser modes — cloud and local — so agents can operate the web exactly like a person

## What is Browser Automation?

Opulent provides two complementary browser environments for autonomous web operation:

- **Cloud Browser Infrastructure** — A fully managed, highly available browser engine in the cloud. The agent browses, clicks, fills forms, extracts data, and executes multi-step workflows — even on complex, JavaScript-heavy single-page applications.
- **Local Browser Operator** — The agent operates your own browser directly, using your active sessions and existing logins. No CAPTCHAs, no re-authentication.

Together, they make Opulent a true web agent — not a chatbot that describes the web, but a system that acts on it.

---

## Cloud Browser Infrastructure

### What it is

Cloud Browser Infrastructure provides a dedicated, isolated browser environment. The agent navigates websites, interacts with elements, and completes workflows — all in a managed container. It handles dynamic content seamlessly and does not use your local machine.

### Why it Matters

Most AI tools can only work with information you paste in. They cannot visit websites, interact with web applications, or access content behind logins.

Cloud Browser enables Opulent to:
- Complete multi-step workflows across many web pages
- Extract data from websites that have no API
- Interact with web applications as a human would
- Browse the web autonomously to gather real-time information
- Log into accounts to perform authenticated actions

### How It Works

**1. Agent Opens the Browser**

When you assign a task requiring web access, Opulent automatically provisions a Cloud Browser instance and navigates to the relevant sites.

**2. Authenticated Sessions**

Log into accounts inside Cloud Browser. The agent uses those authenticated sessions to perform actions on your behalf — updating your CRM, reading emails, posting content, pulling reports.

**3. Take Over When Needed**

For SMS codes, CAPTCHAs, or MFA challenges, you receive a prompt to take over temporarily. Complete the verification, then hand control back to the agent.

### Security and Privacy
- Isolated per-user browser instance
- Encrypted sessions end-to-end
- No password storage
- You control which accounts the agent can access
- Full audit log of every navigation and action

### Accounts to Log Into for Maximum Power

**Productivity & Communication**
- Gmail / Outlook — Read, send, organize emails
- Google Calendar — Schedule meetings, check availability
- Notion — Create pages, update databases
- Slack — Post messages, read channels

**Business & CRM**
- Salesforce / HubSpot — Update leads, log activities, create records
- Stripe — Check payments, generate invoices, review subscriptions
- LinkedIn — Send requests, read messages, monitor mentions

**Research & Data**
- Crunchbase / PitchBook — Company and funding data
- SimilarWeb — Traffic and competitive analysis
- Financial Times / WSJ — Premium news

**Development**
- GitHub — Create issues, review PRs, manage repos
- Jira / Linear — Update tickets, track sprints

---

## Local Browser Operator

### What it is

The Local Browser Operator connects to your desktop browser directly. The agent operates your active browser session — using your existing logins, cookies, and local state — without needing to re-authenticate on any site.

### Why Use Local Instead of Cloud

Cloud Browser uses data center IP addresses. Some sites detect this and trigger extra verification, block access, or require re-login. The Local Browser Operator uses your actual IP address and your existing sessions, which means:

- No re-authentication needed
- No CAPTCHA challenges on sites you're already logged into
- Works on banking, financial, and security-sensitive tools
- Seamless access to internal tools that require corporate network/VPN

### How It Works

1. **Enable**: Go to Settings → Browser → Local Browser Operator → Install the browser extension
2. **Grant Access**: When you assign a task requiring local browser access, approve the session
3. **Autonomous Action**: The agent works in a dedicated tab using your logged-in sessions

### Choosing Between Cloud and Local

| Use Cloud Browser Infrastructure When | Use Local Browser Operator When |
|---|---|
| Researching public websites | Logging into security-sensitive accounts |
| Extracting data at scale | Banking and financial sites |
| Running long-horizon tasks in background | Sites that block data center IPs |
| Research doesn't require your logins | Avoiding CAPTCHA/MFA challenges |
| You want a highly parallelizable environment | You need your residential IP |

---

## Key Capabilities (Both Modes)

### Navigate and Extract

```
"Go to these 30 SaaS pricing pages and extract: plan names, prices,
features per tier, and free trial availability. Return as a CSV."
```

### Interact with Web Applications

```
"Log into our HubSpot account, find all deals in 'Negotiation' stage
that haven't been updated in 14 days, and add a follow-up task to each"
```

### Multi-Step Workflows

```
"Go to LinkedIn, search for VP of Sales at Series B SaaS companies
in North America, collect the first 50 profiles, and extract:
name, company, title, connection degree, and a direct message link"
```

### Authenticated Actions

```
"Log into our Stripe account and generate a monthly revenue report
for Q4 — total MRR, new MRR, churned MRR, and top 10 customers by spend"
```

### Form Filling and Submission

```
"Fill out and submit the vendor onboarding form at this URL using
the information in this spreadsheet — one submission per row"
```

---

## Common Use Cases

| Use Case | Browser Mode | What the Agent Does |
|---|---|---|
| Competitive pricing research | Cloud | Visits 50 competitor pages, extracts pricing |
| CRM data entry | Local | Logs into Salesforce, creates/updates records |
| LinkedIn outreach | Local | Sends connection requests, reads inbox |
| Market research | Cloud | Scrapes 100+ pages simultaneously |
| Banking statement download | Local | Uses your local session, no re-auth |
| News monitoring | Cloud | Visits news sites, extracts and summarizes |
| Job board monitoring | Cloud | Tracks new postings across 10 boards |
| Internal admin tools | Local | Operates tools behind corporate VPN |

---

## Tips

**Be specific about the desired output format:**
- ✅ `"Return as a CSV with columns: company, pricing tier, price, feature list"`
- ❌ `"Get me the pricing info"`

**Use Local Browser for sensitive accounts:**
- ✅ `"Log into my banking portal and download last month's statements"` → Local Browser
- ✅ `"Research 50 public company websites and extract pricing"` → Cloud Browser

**Monitor complex workflows:**
Keep the Browser panel open for multi-step tasks so you can take over immediately if a verification appears.

**Log in ahead of time:**
For Cloud Browser authenticated tasks, log into your accounts once. Sessions persist so the agent can access them without interrupting future workflows.

---

## Common Questions

**Is it secure to let the agent use my accounts?**
Yes. Sessions are encrypted and isolated. The agent cannot access accounts you haven't explicitly logged into. You can revoke access at any time from Settings → Browser.

**What happens if the agent hits a CAPTCHA?**
You'll receive a "Take Over" prompt. Complete the CAPTCHA, then hand control back to the agent.

**Can I see what the agent is doing in real time?**
Yes. The Browser workbench panel shows the live browser session as it operates.

**Can the agent handle JavaScript-heavy single-page apps?**
Yes. Opulent uses highly capable cloud browser infrastructure that natively executes JavaScript and interacts with the DOM exactly as a human would, rather than relying on simple HTTP scraping. Look, read, and act loops ensure full comprehension of dynamic pages.

**Can I stop a browser task mid-execution?**
Yes. Hit Stop in the chat input at any time. The task halts immediately.

---

## Collaboration

**URL:** https://opulent-docs.vercel.app/docs/features/collaboration
**Description:** Collaboration - Opulent documentation

# Collaboration

> Real-time team collaboration on agent tasks — one workspace, one thread, zero version confusion

## What is Collaboration?

Opulent Collaboration brings your entire team into the same agent workspace. Instead of one person running an AI task and then sharing results via email or Slack, your team works together in a shared thread — everyone sees the agent working in real time, anyone can add context or redirect, and the output belongs to the whole team.

This eliminates the coordination overhead that makes AI tools a bottleneck rather than a multiplier: no copy-paste of results, no "which version is current", no parallel agents producing conflicting outputs.

---

## The Problem It Solves

When AI is a solo tool:

1. One person opens Opulent
2. Runs a task
3. Exports or screenshots the result
4. Pastes it into Slack or email
5. Teammates have questions → repeat the task with updated context
6. Two people run similar tasks → conflicting outputs → confusion

With Opulent Collaboration:

- The thread is shared — everyone sees the agent live
- Anyone can add a message to redirect or refine
- The output is in one place, with full history
- No version confusion, no copy-paste, no context loss

---

## How It Works

### Invite to a Thread

Open any task thread and click **Share**. Invite teammates by email or workspace member. They can join immediately.

### Shared Context

All participants see:
- Every message in the thread
- The agent's tool calls and outputs as they happen
- All documents, slides, sheets, and files produced
- The full conversation history

### Real-Time Participation

While the agent is working, any team member can:
- Send a follow-up message to refine the direction
- Upload additional context files
- Ask the agent to focus on a specific sub-task
- Approve or reject a direction before the agent continues

### Output Ownership

Documents, slides, and data produced in a shared thread are available to all participants. No one needs to "send" the file — it's in the shared workspace.

---

## Collaboration in Practice

### Strategy + Execution Loop

```
Thread: Q4 Go-to-Market Planning

Strategy lead: "Research the enterprise AI tooling market — segments, key buyers, top 5 competitors"
Agent: [Runs parallel research → produces market overview]

Marketing: "Good. Now turn this into a 12-slide strategy deck for the leadership meeting"
Agent: [Produces slides]

CEO: "Adjust slide 4 — our differentiation point needs to be sharper"
Agent: [Updates the specific slide]

All three review the final deck together in the thread.
```

---

### Document Review Workflow

```
Thread: Product Launch Blog Post

Writer: "Draft a 1,200-word blog post on our new AI agent platform"
Agent: [Produces draft in Document panel]

Editor: "The intro needs a stronger hook. Rewrite the first two paragraphs"
Agent: [Updates document]

Marketing: "Add a CTA at the end linking to our demo page"
Agent: [Appends CTA section]

Final document is shared — everyone approved it in the thread.
```

---

### Data Analysis Collaboration

```
Thread: Monthly Revenue Review

Finance: "Pull our Stripe MRR for Q4, broken down by plan tier"
Agent: [Queries Stripe → populates Sheets panel]

CFO: "Flag any accounts that churned after the price increase in November"
Agent: [Identifies and highlights at-risk accounts]

Sales: "For each flagged account, find the AE owner in Salesforce and draft a win-back note"
Agent: [Cross-references Salesforce → drafts emails]
```

---

## Access Controls

### Thread Visibility

- Threads are **private by default** — only the creator can see them
- Sharing is explicit — you choose exactly who to invite
- Invitees can see everything in the thread, but cannot add other participants without owner permission

### Workspace Collaboration

Workspace-level sharing gives teammates access to:
- The workspace master instructions and knowledge base
- All threads they've been explicitly invited to

They do **not** automatically see threads they haven't been invited to — even in a shared workspace.

---

## Tips

**Share threads before the task is complete.** The most value comes from collaborating during execution, not just reviewing results.

**Use mentions to direct the agent.** In a shared thread, mentioning a specific colleague's context helps the agent tailor its output: `"The output needs to be useful for @sarah's team, who focus on enterprise accounts"`.

**Keep one thread per topic.** Avoid splitting related work across multiple threads — the agent loses context about what was already done.

**Let the agent serve as meeting notes.** After a team discussion about requirements, have the agent summarize decisions and action items in a shared thread. Everyone has the same record.

---

## Common Questions

**Can participants invite additional teammates?**
Participants can suggest additions, but only the thread owner can approve new members to ensure sensitive tasks remain controlled.

**What happens if two people send messages simultaneously?**
Messages are queued. The agent processes them in order.

**Can I make a thread public (shareable link)?**
Yes. Threads can be shared via a public link for read-only viewing — useful for sharing agent outputs with external stakeholders without granting edit access.

**Can I @mention the agent directly?**
In shared threads, any participant can send messages to the agent. There is no special mention syntax needed — all messages in the thread are seen by the agent.

**Is collaboration available on all plans?**
Yes. Thread sharing is available on all Opulent plans.

---

## Data Analysis & Visualization

**URL:** https://opulent-docs.vercel.app/docs/features/data-analysis
**Description:** Data Analysis & Visualization - Opulent documentation

# Data Analysis & Visualization

> Turn raw data into presentation-ready insights — from live connector queries to polished charts and spreadsheets

Opulent connects to your live data sources, queries them in natural language, analyzes the results, generates charts, and delivers structured outputs to the Sheets panel, Document panel, or Slides — in minutes, without a BI tool or data analyst in the loop.

---

## What it is

Data Analysis in Opulent spans the full pipeline: connect your data sources, ask questions in plain English, run analysis, build visualizations, and deliver structured outputs — all from a single agent interaction. There is no ETL step, no SQL required, and no dashboard to configure.

---

## Quick Start

### Simple Analysis

```
"How much revenue did we generate in Q4? Break it down by month,
product tier, and top 10 customers by spend."
```
*(Requires Stripe connector)*

### Cross-Source Analysis

```
"Compare our Stripe MRR growth with pipeline velocity from HubSpot.
Show correlation between deals closing and revenue spikes.
Display as a line chart in the Sheets panel."
```

### Bulk Data Processing

```
"Upload this 50,000-row CSV of customer orders. Find:
- Average order value by region
- Top 20 products by revenue
- Month-over-month growth trend
- Customers with declining order frequency (churn risk)"
```

### Visualization Request

```
"Generate a bar chart of MRR by plan tier for the last 12 months.
Use our brand colors. Export as a PNG for the board deck."
```

---

## Data Sources

### Live Connectors

Connect once, query anytime. Opulent pulls live data without requiring exports or manual uploads.

| Connector | What You Can Analyze |
|---|---|
| **Stripe** | MRR, churn, ARPU, cohort analysis, subscription changes, revenue by plan |
| **Salesforce** | Pipeline, close rates, rep performance, deal velocity, forecast accuracy |
| **HubSpot** | Funnel metrics, contact growth, email performance, deal stages |
| **Google Analytics** | Traffic, conversion, user behavior, source attribution |
| **PostgreSQL / MySQL** | Any table or view — full SQL-level access via natural language |
| **Snowflake / BigQuery** | Warehouse queries without writing SQL |
| **QuickBooks / Xero** | P&L, cash flow, expense breakdown, accounts receivable aging |
| **GitHub** | Commit velocity, PR cycle time, issue trends, deployment frequency |
| **Linear / Jira** | Sprint velocity, bug rates, feature lead time, team throughput |

### File Uploads

Upload data directly and analyze immediately:
- CSV and Excel files (any size)
- JSON data exports
- PDF reports with embedded tables
- Scanned financial statements (via image understanding)

---

## Analysis Capabilities

### Statistical Analysis
- Descriptive statistics: mean, median, distribution, percentiles
- Trend detection: growth rates, seasonality, anomalies
- Correlation analysis across multiple metrics
- Cohort analysis for user or revenue retention

### Business Intelligence
- Revenue segmentation by product, region, customer tier
- Funnel analysis from lead to close
- Churn prediction based on usage and behavior signals
- Customer lifetime value modeling

### Comparison & Benchmarking
- Period-over-period comparisons (MoM, QoQ, YoY)
- Variance analysis: actual vs. plan vs. prior period
- Competitive benchmarking from public data sources

---

## Visualization

Opulent generates charts and embeds them directly into the Sheets panel, Document panel, or Slides.

### Chart Types

| Chart Type | Best For |
|---|---|
| Bar / Column | Comparing categories, rankings |
| Line | Trends over time |
| Area | Cumulative growth, stacked metrics |
| Pie / Donut | Composition, share breakdowns |
| Scatter | Correlation between two variables |
| Heatmap | Performance by two dimensions (e.g., rep × month) |
| Waterfall | Revenue bridges, cost breakdowns |
| Funnel | Conversion analysis |

### Generating a Chart

```
"Create a waterfall chart showing how we went from $850K MRR in January
to $1.1M in June — contributions from new business, expansion, and churn"
```

```
"Generate a cohort retention heatmap for customers who started in 2025.
Month 0 through Month 12 on the axes."
```

---

## Sheets Panel

The Sheets workbench panel displays live tabular data populated by the agent. It is not a static export — results appear incrementally as the agent queries and processes data.

### Features
- Columns are auto-detected and named based on the data
- Row filtering and sorting via the panel UI
- Agent can append new rows to an existing sheet
- Export to CSV at any time

### Example

```
"Pull all active subscriptions from Stripe. Group by plan and region.
Show MRR by cohort. Open in the Sheets panel."
```

The agent queries Stripe, transforms the data, and populates the Sheets panel with a live spreadsheet — no export required.

---

## Document Integration

Analysis results can be delivered directly to the Document panel as structured content:

```
"Analyze our Q4 Stripe data, write a 3-paragraph executive narrative,
embed the key metrics as a formatted table, and add a line chart
showing month-over-month MRR growth"
```

The Document panel receives the written narrative, the data table, and the embedded chart in one response.

---

## Common Use Cases

| Use Case | Data Source | Output |
|---|---|---|
| Revenue Review | Stripe | MRR, churn, ARPU table + line chart |
| Sales Forecast | Salesforce | Pipeline report with close probability |
| Churn Analysis | Stripe + product DB | At-risk customer list |
| Marketing Attribution | Google Analytics + HubSpot | Channel ROI breakdown |
| Engineering Health | GitHub + Linear | Sprint velocity + PR cycle time |
| Financial Close | QuickBooks | P&L, cash flow, AR aging |
| Customer Segmentation | Any CRM | Segments by value, activity, or behavior |
| Competitive Benchmarking | Web research | Feature/price comparison matrix |

---

## Tips for Better Analysis

Be specific about the metric you want:
- ❌ `"How are we doing?"`
- ✅ `"What is our MRR growth rate MoM for the last 6 months, broken down by plan tier?"`

Specify the time range:
- ❌ `"Recent sales data"`
- ✅ `"Q4 2025 (October 1 – December 31)"`

Define how you want the output:
- ✅ `"Output as a table in the Sheets panel"`
- ✅ `"Include a bar chart and embed it in the Document"`
- ✅ `"Generate a slide deck with one chart per key metric"`

Ask for interpretation, not just numbers:
- ✅ `"Analyze the data and tell me what's driving churn — don't just show the numbers"`
- ✅ `"Identify the top 3 anomalies and explain what might be causing them"`

---

## Common Questions

**Do I need to know SQL?**
No. Describe what you want in plain English. The agent writes and executes the query.

**Can I upload my own data files?**
Yes. Upload CSV, Excel, JSON, or PDF files and analyze them immediately.

**How does the agent connect to my database?**
Via the Connectors panel. You provide credentials once; the agent handles all queries.

**Can the agent detect anomalies automatically?**
Yes: `"Scan our last 12 months of Stripe data and flag anything unusual"` produces a list of anomalies with explanations.

**Can I save and re-run an analysis?**
Yes. Save any analysis as a workflow and schedule it (see Scheduled Tasks). The agent re-runs the exact same analysis on the latest data.

---

## Design View

**URL:** https://opulent-docs.vercel.app/docs/features/design-view
**Description:** Design View - Opulent documentation

# Design View

> Iterative visual editing — mark any element in an image and change it precisely, without regenerating from scratch

## What is Design View?

Design View is Opulent's integrated visual editing mode that transforms image generation from a one-shot process into an iterative workflow. Instead of rewriting a prompt and hoping a new generation is better, you mark specific elements in an existing image and give targeted instructions for exactly what to change — everything else stays untouched.

This is not a standalone tool. It is a capability of the Opulent agent, meaning you can move fluidly between generating images, refining them in Design View, and incorporating them into documents, slides, and presentations — all within one workspace.

---

## How to Use Design View

### Step 1: Generate Your Base Image

Start with a prompt that produces a strong initial concept. The better the base, the less refinement you need.

```
"A photorealistic exterior shot of a modern SaaS company office building —
glass facade, landscaped entrance, warm afternoon light"
```

```
"A clean product mockup of our mobile app on an iPhone 15 Pro,
on a white marble surface, professional photography style"
```

```
"A flat design illustration of an enterprise data pipeline —
boxes, arrows, icons, brand color palette"
```

### Step 2: Mark and Refine

Once you have your image, activate Design View and use the **Mark Tool** to select specific elements:

1. Click **Mark** in the image panel
2. Draw a selection around the element to change (a button, a background, a person's clothing, a UI component)
3. Describe the change for that specific element:

**Examples:**
- Select the background: `"Change to a deep navy blue gradient"`
- Select a UI button: `"Make this button rounded with a green fill"`
- Select a product: `"Change the color to matte black"`
- Select text on a poster: `"Change to: 'Q4 Revenue Report 2025'"`

The rest of the image remains unchanged — consistent lighting, composition, and style are preserved.

### Step 3: Edit Text Elements

If your image contains text (a poster, a UI screen, an infographic), click **Edit Text** to extract all text elements and modify them without disturbing the image:

- Change copy on a mockup screen
- Update headline text on a slide background
- Revise labels on a diagram

### Batch Edits

Mark multiple areas in a single pass — one instruction per area — and submit them all at once. Opulent processes all changes in a single generation, saving time on complex multi-element edits.

---

## Reference Images

Add elements to your image using a reference photo:

```
"Add the logo from this reference image to the top-left corner
of the office building exterior"
```
*(Upload reference image)*

```
"Place this product on the desk in the image, matching the lighting"
```
*(Upload product photo)*

---

## Common Uses

### Product & Marketing Design
- Product mockups with iterative refinements
- Ad creative variants (swap background, change CTA color, update headline)
- Social media assets adapted from a base image

### UI/UX Prototyping
- App screen mockups with precise UI element edits
- Before/after design comparisons
- Wireframe-to-mockup iterations

### Presentation Visuals
- Custom slide backgrounds with specific element changes
- Infographics refined element by element
- Brand-consistent illustrations iterated from a base style

### Document Assets
- Report cover images
- Blog post header illustrations with text overlay adjustments
- Diagram refinements without full regeneration

---

## Tips for Better Results

**Start with a strong base image:**
- ✅ Spend time on your initial prompt — composition, lighting, style
- ✅ `"Photorealistic, professional, centered subject, shallow depth of field"`
- ❌ Vague prompts produce vague bases that are harder to refine

**Be specific with Mark instructions:**
- ✅ `"Change this to a muted sage green with a subtle texture"`
- ✅ `"Replace with a modern sans-serif font in white"`
- ❌ `"Make this better"`

**Use reference images for branded elements:**
- ✅ Upload your logo, product, or brand asset and reference it directly

**Iterate in small steps:**
- ✅ One or two changes per round, review, then continue
- The power is in the iteration — don't try to perfect everything in one pass

---

## Common Questions

**How is this different from just regenerating with a new prompt?**
Regeneration creates a completely new image — different composition, different details, different everything. Design View changes only what you mark, preserving everything else: lighting, perspective, style, and all unselected elements. This makes consistent brand assets and product mockups practical.

**Can I use Design View on images I uploaded, not just ones I generated?**
Yes. Upload any image and use the Mark Tool to make targeted edits.

**Can I undo a change?**
Yes. The image panel maintains version history. Click any previous version to revert.

**Is there a limit on how many marks per edit?**
You can mark multiple areas in a single edit session. Complex images with many marks may take slightly longer to process.

**Can I use Design View on mobile?**
Yes. On the Opulent mobile interface: press and hold any area of an image to create a selection, then type or dictate your instruction.

---

## Document Editor

**URL:** https://opulent-docs.vercel.app/docs/features/document-editor
**Description:** Document Editor - Opulent documentation

# Document Editor

> A live collaborative document surface where agents write, structure, and enrich content as you watch

## What it is

The Document Editor is a full-featured rich text editor built into the Opulent Workbench. Unlike a chat window where the agent produces blocks of text you copy elsewhere, the Document panel is a persistent, live document that the agent writes directly into — and that you can edit simultaneously.

The result is a real deliverable, not a chat response: a formatted, embeddable, exportable document that combines the agent's research and writing with your edits, all in one place.

---

## Quick Start

### Draft a Document

```
"Write a technical proposal for migrating our infrastructure to Convex.
Include: executive summary, current state, proposed architecture, migration plan,
risks, and cost estimate. Open in the Document panel."
```

### Research and Write

```
"Research the top 5 enterprise CRM platforms. Write a structured evaluation
covering: pricing, features, integrations, G2 ratings, and our team's
likely fit with each. Format as a decision document."
```

### Collaborative Draft

```
"Draft an outbound email sequence for our new enterprise tier.
5 emails: cold intro, value add, case study, direct ask, break-up email.
I'll edit each one — write them all in the Document panel."
```

---

## Rich Content Support

The Document Editor supports full rich text formatting plus embedded media — far beyond what a chat window can produce.

### Text Formatting
- Headings (H1–H3)
- Bold, italic, inline code
- Bullet lists and numbered lists
- Blockquotes
- Horizontal dividers
- Links

### Embedded Media
- **Images** — Uploaded files or AI-generated images inline
- **Audio** — Playable audio player embedded in the document
- **Video** — Embedded video with controls
- **YouTube** — Any YouTube URL rendered as an inline player
- **Code Blocks** — Syntax-highlighted code in any language

### Structured Content
- **Tables** — Created and populated by the agent or manually
- **Task Lists** — Checkable to-do items with completion state
- **Callouts / Blockquotes** — Highlighted information blocks

---

## How Agents Write to the Document

Agents use dedicated document tools to write content:

- **Append** — Add content to the end of the document
- **Insert** — Place content at a specific position
- **Replace** — Update a specific section
- **Insert Media** — Embed images, audio, video, or YouTube at a position

You watch the document populate in real time as the agent works.

---

## Common Uses

### Business Documents
- Proposals and RFPs
- SOW and contracts (draft)
- Strategic memos
- Board updates

### Research & Reports
- Market analysis reports
- Competitive landscape documents
- Industry research summaries
- Due diligence documents

### Content Production
- Blog posts and articles
- Product documentation
- Email sequences
- Landing page copy

### Internal Operations
- Meeting notes and action items
- Standard operating procedures
- Project retrospectives
- Onboarding guides

---

## Combining with Other Features

The Document Editor is most powerful when combined with Opulent's other capabilities:

### Document + Data Analysis

```
"Query our Stripe data for Q4 churn analysis. Write a narrative report
with the findings, embed the key metrics as a table, and add a line chart
of churn rate over time — all in the Document panel."
```

### Document + Research

```
"Research the regulatory landscape for AI in financial services across
the US, EU, and UK. Write a 2,000-word structured report with citations,
a jurisdiction comparison table, and a summary of key compliance requirements."
```

### Document + Slides

```
"Write a detailed research document on the future of enterprise AI adoption.
Once complete, use it as the source material to create a 12-slide presentation
covering the same findings in a deck format."
```

### Document + Audio

```
"Write a product overview document. Then generate an audio narration of the
executive summary and embed it at the top of the document so stakeholders
can listen before reading."
```

---

## Editing and Iterating

The Document Editor is bidirectional — you edit the content, and the agent can continue from where you left off.

```
"The section on competitive positioning needs more depth. Expand it with
specific examples from our last 3 competitive deals."
```

```
"Rewrite the executive summary to be more concise — 3 sentences max."
```

```
"Add a new section after 'Implementation Plan' covering risk mitigation."
```

The agent reads the current document state before making changes, so its edits are always context-aware.

---

## Export

Export documents in multiple formats:

| Format | Notes |
|---|---|
| **Markdown** | Full fidelity, including tables and code blocks |
| **HTML** | Self-contained file with inline styles |
| **Plain Text** | Clean text without formatting |

Click the Export button in the Document panel toolbar.

---

## Tips

**Give the agent a structure to follow.** Specifying sections upfront produces better results than letting the agent decide:
- ✅ `"Include: Executive Summary, Problem Statement, Proposed Solution, Timeline, Budget"`
- ❌ `"Write a proposal"`

**Use the Document panel for anything you'll share.** The panel produces a real deliverable — not a chat blob to copy-paste.

**Edit inline, then ask for refinements.** Make quick edits yourself for small changes. For larger restructuring, ask the agent.

**Combine with web research for grounded documents.** For any research-heavy doc, the agent searches, synthesizes, and writes — fully cited.

---

## Common Questions

**Can multiple people edit the document simultaneously?**
Real-time multiplayer editing is on the roadmap. Currently, one editor at a time.

**Does the agent see my edits when I make changes?**
Yes. When you send a follow-up message, the agent reads the current document state — including your edits.

**Can I use the Document panel without an agent?**
Yes. The Document panel functions as a standalone editor. The agent is optional.

**Is there a document length limit?**
No hard limit. Documents of 10,000+ words are supported.

**Can I embed documents from the panel into other outputs?**
Yes. Document content can be referenced in slide creation, email generation, and other downstream tasks.

---

## Ecosystem Connectors

**URL:** https://opulent-docs.vercel.app/docs/features/ecosystem-connectors
**Description:** Ecosystem Connectors - Opulent documentation

# Ecosystem Connectors

> Connect Opulent to your entire stack — and let agents act across every tool you use

## What it is

Ecosystem Connectors give Opulent agents direct, authenticated access to the tools your business runs on. Instead of copying data between systems or manually triggering actions, agents read from and write to your stack autonomously — querying Stripe for revenue data, updating Salesforce records, posting to Slack, committing to GitHub, or ingesting from your database, all in a single workflow.

---

## Quick Start

```
"Check our Stripe account for any subscriptions that churned this week.
For each churned customer, look them up in HubSpot, draft a personalized
win-back email, and add a follow-up task in the CRM."
```

```
"Query our PostgreSQL database for all users inactive for 30+ days.
Cross-reference with Stripe to see which have active subscriptions.
Post a list of at-risk accounts to #retention in Slack."
```

```
"Pull this week's closed deals from Salesforce. For each, create a
Notion onboarding page using our template, then send a welcome email
from Gmail with the onboarding link."
```

---

## Available Connectors

### Revenue & Finance
| Connector | What Agents Can Do |
|---|---|
| **Stripe** | Query MRR, subscriptions, churn, invoices; create payment links; manage customers |
| **QuickBooks** | Read P&L, cash flow, invoices; log expenses; reconcile transactions |
| **Xero** | Financial reporting, invoice management, expense tracking |

### CRM & Sales
| Connector | What Agents Can Do |
|---|---|
| **Salesforce** | Read/create/update leads, contacts, accounts, opportunities, tasks |
| **HubSpot** | Manage contacts, deals, pipeline; log activities; trigger sequences |
| **Pipedrive** | Deals, pipeline management, activity logging |

### Communication
| Connector | What Agents Can Do |
|---|---|
| **Slack** | Post messages, read channels, create channels, send DMs |
| **Gmail** | Read, send, organize, label emails; manage drafts |
| **Outlook** | Read and send emails, manage calendar |
| **Twilio** | Send SMS notifications |

### Productivity & Knowledge
| Connector | What Agents Can Do |
|---|---|
| **Notion** | Create/update pages and databases, read workspace content |
| **Google Drive** | Upload/download files, create docs and sheets, organize folders |
| **Google Sheets** | Read/write data, create new sheets, update existing ones |
| **Airtable** | Query bases, create/update records, manage views |

### Development
| Connector | What Agents Can Do |
|---|---|
| **GitHub** | Create issues/PRs, commit code, read repo content, manage projects |
| **Linear** | Create/update issues, manage sprints, track velocity |
| **Jira** | Create/update tickets, manage boards, track progress |

### Data & Analytics
| Connector | What Agents Can Do |
|---|---|
| **PostgreSQL / MySQL** | Full read/write SQL queries in natural language |
| **Snowflake / BigQuery** | Warehouse queries and transformations |
| **Google Analytics** | Traffic, conversion, and behavior reports |
| **Mixpanel / Amplitude** | Product analytics, funnel analysis, retention |

### E-commerce
| Connector | What Agents Can Do |
|---|---|
| **Shopify** | Orders, products, inventory, customer data |
| **Amazon Seller** | Listings, orders, fulfillment tracking |

---

## How to Connect

1. Go to **Settings → Connectors** (or click **Apps** in the chat input)
2. Find the connector you want to enable
3. Click **Connect** and complete OAuth authorization (or enter your API key)
4. Done — agents in your workspace can now access this tool

Credentials are encrypted and stored securely. You can revoke access at any time.

---

## Multi-Connector Workflows

The real power of Ecosystem Connectors is combining multiple tools in a single agent workflow. Opulent coordinates across services automatically.

### Example: Sales Intelligence Pipeline

```
"Every Monday at 8 AM:
1. Pull deals stuck in 'Proposal' stage for 14+ days from Salesforce
2. Research each company on LinkedIn and Crunchbase for recent news
3. Draft a personalized follow-up email per deal
4. Add a task to each deal in Salesforce
5. Post a summary to #sales in Slack"
```

*Connectors used: Salesforce + web research + Gmail + Slack*

---

### Example: Finance Automation

```
"When a new invoice arrives in Gmail (filter: subject contains 'Invoice'):
1. Extract the vendor, amount, due date, and invoice number
2. Log it to our QuickBooks accounts payable
3. Create a calendar reminder 3 days before due
4. Post to #finance in Slack for approval if amount > $5,000"
```

*Connectors used: Gmail + QuickBooks + Google Calendar + Slack*

---

### Example: Engineering Ops

```
"Each Friday at 5 PM:
1. Pull this week's merged PRs from GitHub
2. Get the corresponding Linear tickets that were closed
3. Write a weekly engineering update
4. Post to Notion Engineering wiki
5. Share in #eng-updates on Slack"
```

*Connectors used: GitHub + Linear + Notion + Slack*

---

## MCP (Model Context Protocol) Support

Beyond pre-built connectors, Opulent supports **MCP** — an open protocol that lets any tool expose capabilities to AI agents. If a tool you use has an MCP server, Opulent can connect to it with no custom integration required.

This means Opulent's connector ecosystem grows in lockstep with the broader MCP ecosystem — not limited to what Opulent has manually built.

### Connecting an MCP Server

```
Go to Settings → Connectors → MCP Servers → Add Server
Enter the MCP server URL and any required credentials.
```

Once connected, the agent can discover and use all tools the MCP server exposes.

---

## Tips

**Connect the tools you use most first.** Start with Slack (for output delivery), your CRM, and your primary data source. These three enable the most powerful workflows immediately.

**Use Slack as a universal delivery channel.** Almost every automated workflow benefits from a Slack notification. Connect Slack first.

**Grant read-only access when possible.** For research and reporting workflows, read-only API keys reduce risk without limiting capability.

**Test connector access with a simple query.** Before building a complex workflow, verify the connection: `"Pull my last 5 Stripe invoices"` confirms Stripe is working.

---

## Common Questions

**How are my credentials stored?**
All API keys and OAuth tokens are encrypted at rest. Opulent does not log or expose credentials in any output.

**Can I revoke access to a connector?**
Yes. Go to Settings → Connectors → Connected → select the connector → Disconnect.

**Can agents write to my tools, not just read?**
Yes. Agents can create, update, and delete records with your authorization. For sensitive write operations (deletions, financial transactions), you can require explicit confirmation.

**What if a connector I need isn't listed?**
Connect it via MCP if the vendor provides an MCP server. Or use the browser to access the tool's web interface directly.

**Do connectors cost extra?**
No. Connectors are included in all plans. Usage of the connected tools is subject to the terms of those tools.

---

## Master Instructions

**URL:** https://opulent-docs.vercel.app/docs/features/instructions
**Description:** Master Instructions - Opulent documentation

# Master Instructions

> The always-on system prompt that defines your agent's identity, constraints, and operational blueprint.

## What are Master Instructions?

The biggest friction point in using AI is the "blank canvas" problem: having to spend two paragraphs explaining who you are, what your company does, and how you want things formatted every single time you start a new conversation.

In Opulent, workspaces are governed by **Master Instructions**. This is an overarching, always-on directive that blankets every single task, subagent, and workflow executed within that environment. You configure it once, and the agent obeys it permanently.

---

## Anatomy of a Perfect Master Instruction

A high-performing Master Instruction acts as an employee onboarding document. It should dictate behavior across four pillars:

### 1. Identity & Role
Tell the agent exactly who it is acting as.
```text
"You are a Senior Systems Architect for Acme Corp. Your role is to review PRs, 
audit cloud infrastructure, and propose scalable backend refactors."
```

### 2. Format & Style
Mandate output structures to avoid having to correct the agent's tone repeatedly.
```text
"Never use corporate jargon or marketing speak. Always output documentation 
in Markdown, utilizing exact file paths. Prefer bullet points over long paragraphs."
```

### 3. Workflow Constraints
Set guardrails on how the agent is allowed to execute tasks, especially when using tools like the Cloud Browser Engine or Repo Access.
```text
"When reviewing code, never auto-commit directly to the main branch. 
Always create a new branch prefixed with `agent-review/` and open a draft PR."
```

### 4. Naming & Tooling Conventions
Inform the agent about internal company standards.
```text
"We use Jira for ticket tracking and Slack for messaging. 
All date formats must be YYYY-MM-DD. Our primary database is PostgreSQL."
```

---

## Compounding Efficiency

When you combine **Master Instructions** with the **Knowledge Base** and the **Connected Cortex** (Memory), you create an incredibly autonomous environment. 

1. The Master Instruction tells the agent *how* to act.
2. The Knowledge Base provides the *facts* it needs to act.
3. The Connected Cortex remembers *what* it has already done.

This trifecta allows you to start complex tasks with incredibly short prompts:
- `"Execute a weekly review."`
The agent already knows (via instructions) what a weekly review entails, knows (via knowledge) what the KPIs are, and knows (via memory) what last week's numbers were.

---

## Global vs. Local Scope

It is highly recommended to keep Master Instructions tightly scoped by creating separate Workspaces for different departments.
- **Sales Workspace Instruction:** `"You are an aggressively helpful SDR focused on lead qualification..."`
- **Engineering Workspace Instruction:** `"You are a cautious, security-first Site Reliability Engineer..."`

By isolating these personas, you prevent the SDR agent from accidentally utilizing engineering jargon, and vice-versa.

---

## Knowledge Base

**URL:** https://opulent-docs.vercel.app/docs/features/knowledge
**Description:** Knowledge Base - Opulent documentation

# Knowledge Base

> Equip your agents with instant access to your company's deepest documentation and data.

## What is the Knowledge Base?

General-purpose agents rely on pre-trained data that is often outdated or irrelevant to your specific business constraints. The Opulent **Knowledge Base** gives you the ability to tightly couple your proprietary documents directly to an agent's workspace. 

When you upload files, Opulent securely processes, chunks, and vector-indexes the content. Utilizing advanced **Retrieval-Augmented Generation (RAG)**, the agent mathematically searches the indexing space to pull the exact paragraphs, code snippets, or policies required to answer your prompt, guaranteeing ground-truth accuracy.

---

## Supported Formats

You can upload a wide variety of static context directly to a workspace:
- **PDFs:** Internal playbooks, product manuals, investor pitches.
- **Text & Markdown:** Codebase READMEs, engineering guidelines, API specifications.
- **Spreadsheets & CSVs:** Static pricing matrices, locale mappings, demographic datasets.

---

## How it Upgrades Agent Workflows

### Engineering Support
Upload your entire architectural decision record (ADR) and API documentation.
- `"Write a new authentication endpoint."`
*The agent will seamlessly check the Knowledge Base, discover your company mandates OAuth2 with specific header formats, and write the code correctly on the first try.*

### Sales Enablement
Upload your latest competitive battlecards and pricing tiers.
- `"Draft a cold email to Acme Corp highlighting why we are better than Competitor X."`
*The agent retrieves the specific messaging pillars regarding Competitor X from your uploaded battlecards, ensuring the tone and claims are 100% accurate and brand-aligned.*

### Human Resources
Upload your employee handbook and benefits policies.
- `"How many PTO days roll over internally?"`
*Instead of a hallucinated answer, the agent cites the exact page and section of the uploaded HR PDF.*

---

## Managing Your Knowledge Space

- **Dynamic Updates:** If your API changes or your Q3 goals shift, simply delete the old file and upload the new one. The vector index is rebuilt instantly, and all future tasks executed in that Workspace instantly inherit the updated facts.
- **Workspace Isolation:** Files uploaded to the "Finance Workspace" are completely invisible to the "Engineering Workspace." This strict sandboxing prevents context pollution and enforces security boundaries between agent personas.

---

## Memory

**URL:** https://opulent-docs.vercel.app/docs/features/memory
**Description:** Memory - Opulent documentation

# Memory

> Persistent context that lets agents remember, learn, and build on past conversations

## What is Memory?

Memory is Opulent's persistent context system that allows agents to maintain awareness across sessions. Instead of starting each conversation from scratch, your agents remember who you are, what you've worked on, and what preferences matter to you.

This transforms one-off interactions into continuous relationships — agents that genuinely know you.

---

## How Memory Works

### 1. Connected Cortex Persistence

Every conversation builds on previous ones via the **Connected Cortex**, Opulent's real-time memory synchronization engine. Your agent remembers:
- Previous tasks, decisions, and **trajectory memory** (how you solved a problem, not just the final result)
- Your communication style and preferences
- Multi-path memory (tracking parallel trains of thought across different tasks)
- Feedback you've given about past results

### 2. Semantic Indexing

Memory uses embeddings to create a searchable index of your interactions. This means:
- Natural language queries find relevant past context
- The agent surfaces related information proactively
- You can ask "what did we work on last week?" and get an answer

### 3. Selective Recall

Not everything needs to be remembered. You control:
- What gets stored permanently vs. session-only
- Which memories are most important
- When to clear or reset memory

---

## Use Cases

### Ongoing Projects

Start a project today, return next week, and pick up exactly where you left off. The agent knows what you've built, what decisions were made, and what remains.

### Personal Preferences

Your agent learns your preferences over time — preferred communication tone, file organization style, working hours, and recurring patterns.

### Team Knowledge

For team deployments, Memory shares relevant context across team members while respecting privacy boundaries.

---

## Privacy & Control

- All memory data is encrypted at rest
- You can export, view, or delete your memory at any time
-granular controls let you keep specific memories while clearing others
- Memory can be disabled entirely for maximum privacy

---

## Multimedia Processing

**URL:** https://opulent-docs.vercel.app/docs/features/multimedia-processing
**Description:** Multimedia Processing - Opulent documentation

# Multimedia Processing

> Generate images, produce video, embed audio, and analyze any media — all inside your workspace

Opulent works across every media type. Generate original images on demand, produce short video clips, embed audio and YouTube content into documents, and extract insights from images and video — all woven directly into your agent workflows and Document panel.

---

## Capabilities Overview

| Capability | What It Does | Example Use |
|---|---|---|
| Image Generation | Create custom images from text descriptions | Product mockups, illustrations, slide visuals |
| Image Understanding | Analyze and extract info from any image | Document scanning, chart re-creation, visual QA |
| Video Generation | Generate short video clips from a description | Product teasers, social content, explainer clips |
| Audio Embed | Embed playable audio clips into documents | Narration, music, recorded walkthroughs |
| Voice Output | Convert text to natural spoken audio | Voiceovers, accessibility, podcast drafts |
| Speech to Text | Transcribe audio or video to text | Meeting notes, interview transcripts |
| YouTube Embed | Embed any YouTube video inline | Reference material, tutorials, demos |
| Video Understanding | Extract insights from uploaded video | Competitor analysis, meeting summaries |

---

## Image Generation

### Quick Start

```
"Generate a product mockup showing our dashboard on a MacBook Pro,
clean white background, professional photography style"
```

```
"Create a diagram showing our customer journey from first visit to
paying customer, flat design, brand colors"
```

```
"Generate a hero image for our landing page — abstract, dark theme,
glowing blue accents, wide format 1920x1080"
```

### Common Uses

Product Visuals:
- Product mockups and prototypes
- Feature illustrations and UI concepts
- App store screenshots and demos

Marketing Assets:
- Social media graphics (square, portrait, landscape)
- Blog post header images
- Ad creatives with specified aspect ratios

Presentations:
- Custom slide backgrounds per section
- Concept illustrations for abstract ideas
- Visual metaphors that replace stock photos

Diagrams & Architecture:
- System architecture diagrams
- Process and workflow flows
- Infographics combining icons and data

### Tips for Better Images

Be specific about style:
- ✅ `"Flat design illustration, bright colors, icon-style"`
- ✅ `"Minimalist, modern, professional photography, shallow depth of field"`
- ❌ `"Make it look good"`

Describe composition:
- ✅ `"Centered subject, blurred background, natural window lighting"`
- ❌ `"A picture of our app"`

Specify use case and format:
- ✅ `"For Instagram post, square format, bold text overlay space at bottom"`
- ✅ `"For presentation slide, 16:9 wide format, subtle texture background"`

---

## Image Understanding

### Quick Start

```
"Analyze this screenshot and extract all visible text into a document"
```
*(Upload image)*

```
"What products are shown in this catalog page? Extract names, prices,
and any SKU numbers visible."
```
*(Upload image)*

```
"Recreate this chart as an editable data table with the exact values shown"
```
*(Upload image)*

### Common Uses

Document Processing:
- Extract text from screenshots and scans
- Parse receipts, invoices, and purchase orders
- Read handwritten notes and whiteboard photos

Visual Analysis:
- Re-create charts and graphs as live data
- Identify objects, logos, and UI elements
- Describe and annotate image content

Quality Control:
- Compare two product photos for differences
- Verify design specs are met in screenshots
- Check marketing assets for brand compliance

### Example Tasks

```
"Extract all text from these 10 product images and organize into a spreadsheet"
```

```
"Analyze this architecture diagram and create a written description of
every component and how they connect"
```

```
"Compare these two app screenshots and list every UI difference"
```

---

## Video Generation

> Opulent supports text-to-video generation for short clips and animations.

### Quick Start

```
"Generate a 5-second product teaser showing our logo animating in
with a dark background and particle effects"
```

```
"Create a short explainer clip for this feature — professional style,
no text overlay, abstract motion graphics"
```

### Common Uses

- Product teasers and social media clips
- Abstract motion graphics for presentations
- Animated diagrams and process illustrations
- Brand intro sequences

### Checking Video Status

Video generation runs asynchronously. After requesting a video:

```
"Check the status of my video generation"
```

Once complete, the video is available in AI Drive and can be embedded directly into any Document.

---

## Audio Embeds

> Embed playable audio directly into documents and presentations — no external tools needed.

### Quick Start

```
"Embed the audio file at this URL as a playable player in the document:
https://example.com/narration.mp3"
```

```
"Add background music to this document — label it 'Product Demo Walkthrough'"
```

Using the toolbar: open the Document panel → click the **♪ Music** icon → enter the audio URL.

### Common Uses

- Meeting recordings embedded alongside notes
- Product demo narration in proposals
- Podcast clips embedded in research documents
- Accessibility versions of written content

---

## Voice Output

> Convert any text to a natural audio narration.

### Quick Start

```
"Convert this blog post to an audio narration file, professional tone"
```

```
"Create a voiceover for this presentation script — friendly, energetic,
moderate pace"
```

```
"Generate audio descriptions of these 10 products for our website"
```

### Common Uses

Content Creation:
- Blog posts converted to audio
- Podcast scripts produced as audio files
- Presentation narration tracks

Accessibility:
- Audio versions of long documents
- Voiceover tracks for screen recordings

Marketing:
- Ad voiceover copy
- Product demo narration
- Social media audio content

### Voice Options

Tone: Professional, friendly, casual, energetic, calm
Pace: Fast, moderate, slow
Style: Conversational, formal, educational, promotional

---

## Speech to Text

> Transcribe any audio or video file to text with speaker labels and timestamps.

### Quick Start

```
"Transcribe this interview recording"
```
*(Upload audio file)*

```
"Convert this 1-hour webinar recording to text. Include:
- Full transcript
- Executive summary
- Key takeaways
- Q&A section extracted separately"
```

```
"Transcribe these 20 customer support calls and identify the most
common issues mentioned across all of them"
```

### Common Uses

Meeting Notes:
- Transcribe calls and standup recordings
- Extract action items automatically
- Build searchable meeting archives

Content Repurposing:
- Convert podcasts to blog posts
- Create show notes from audio
- Extract quotable moments with timestamps

Research:
- Transcribe user interview recordings
- Analyze customer support calls at scale
- Process focus group audio

### Features

- **Speaker identification** — Distinguish between multiple speakers
- **Timestamps** — Mark when each segment was said
- **Formatting** — Proper punctuation, paragraphs, and capitalization
- **Accuracy** — High accuracy across accents, background noise, and technical terminology

---

## YouTube Embeds

> Embed any YouTube video inline in documents and presentations.

### Quick Start

```
"Embed this YouTube video in the document: https://youtu.be/VIDEO_ID"
```

Using the toolbar: open the Document panel → click the **▶ YouTube** icon → paste the URL or video ID.

### Common Uses

- Embed tutorial videos alongside written instructions
- Add reference demos to proposals
- Include competitor videos in research documents
- Add explainer videos to onboarding documents

---

## Combining Multiple Modes

Opulent can combine all media capabilities in a single workflow:

### Example 1: Video to Document

```
"Watch this product demo video, transcribe it, extract key features
and pricing mentioned, generate a summary diagram, and write a
blog post with all findings embedded in the Document panel"
```

### Example 2: Presentation with Full Media

```
"Create a 10-slide presentation about our Q4 results. Generate a custom
illustration for each section. Add a voiceover narration track for the
full deck. Embed a reference YouTube tutorial in the appendix slide."
```

### Example 3: Bulk Image Analysis to Report

```
"Analyze these 50 product photos, extract visible text and product
details from each, generate a comparison chart, and create a
slide deck with findings and side-by-side image comparisons"
```

---

## Quick Use Cases

| Use Case | Input | Output |
|---|---|---|
| Product Mockups | Description | Generated image |
| Meeting Notes | Video / audio recording | Transcript + summary |
| Blog Audio | Text article | Audio narration file |
| Document Scanning | Photo of document | Extracted text |
| Video Analysis | Competitor video URL | Feature comparison |
| Podcast Show Notes | Audio file | Transcript + summary |
| Slide Visuals | Topic description | Custom generated images |
| Demo Narration | Presentation script | Voiceover audio |
| YouTube Reference | URL | Embedded player in doc |

---

## Common Questions

**What image formats are supported?**
PNG, JPG, WEBP, GIF, SVG for uploads. Generated images are delivered as PNG or JPEG at requested dimensions.

**What video formats work for upload?**
MP4, MOV, WEBM, and most common formats. Generated videos are delivered as MP4.

**What audio formats work for transcription?**
MP3, WAV, M4A, WEBM, OGG, and most common audio formats.

**Can I generate images in specific sizes?**
Yes. Specify dimensions: `"Generate a 1920x1080 image..."` or `"Square format, 1:1 ratio for Instagram"`.

**How accurate is speech transcription?**
Very high accuracy, including multiple speakers, accents, and technical vocabulary.

**Can I embed audio from an external URL?**
Yes. Any direct audio URL (mp3, wav, ogg) can be embedded as a playable player in Documents.

---

Bottom line: Opulent handles every media type natively — generate images, produce video, embed audio, transcribe speech, and analyze visual content — all integrated into your documents, slides, and agent workflows without leaving the platform.

---

## Opulent Slides

**URL:** https://opulent-docs.vercel.app/docs/features/opulent-slides
**Description:** Opulent Slides - Opulent documentation

# Opulent Slides

> Complete, designed presentations from a single description — research, content, visuals, and speaker notes included

Opulent creates full slide decks from a brief. The agent conducts research, structures the narrative, designs slides using professional themes, generates or sources custom visuals, and writes speaker notes — delivering a presentation-ready deck in minutes, not hours.

---

## What it is

Opulent Slides is a dedicated workbench surface that produces complete, styled HTML slide decks. Unlike tools that format text into generic templates, Opulent's agent plans the narrative, generates content per slide, applies design themes, and embeds generated images and charts — all automatically.

The resulting slides are fully self-contained HTML documents: no external dependencies, no CDN calls, no internet required to present.

---

## Quick Start

### From a Brief

```
"Create a 10-slide investor pitch for our AI agent platform.
Cover: problem, solution, market size, product demo, competitive advantage,
traction, team, and ask. Use the Executive theme."
```

### From Your Data

```
"Create a 6-slide Q4 board update using our Stripe MRR data and
the pipeline report in Google Drive. Include a chart for each
key metric. Executive theme, no fluff."
```

### From Research

```
"Research the state of enterprise AI adoption in 2026. Create a
15-slide thought leadership deck covering: key trends, industry
breakdowns, adoption barriers, and recommended actions.
Generate a custom illustration for each section."
```

### Iterating on a Deck

```
"Change slide 3 to focus more on the enterprise segment.
Add a comparison table between our tiers on slide 7.
Move the pricing slide to before the CTA."
```

---

## How It Works

1. **Plan** — The agent reads your brief, structures a logical narrative arc, and defines the slide sequence
2. **Research** — For data-driven decks, the agent queries your connectors (Stripe, HubSpot, etc.) or the web for current information
3. **Write** — Each slide gets a headline, body content, and speaker notes tuned to your audience
4. **Design** — A professional theme is applied with consistent typography, spacing, and color
5. **Visualize** — Custom images are generated for conceptual slides; charts are generated from data
6. **Deliver** — The deck is rendered as live HTML in the Slides panel, ready to present or export

---

## Themes

| Theme | Style | Best For |
|---|---|---|
| **Executive** | Clean, dark, authoritative | Board decks, investor pitches, leadership reviews |
| **Terracotta** | Warm, earthy, bold | Brand decks, product launches, marketing |
| **Charcoal** | Minimal, sharp, modern | Technical deep-dives, engineering reviews |
| **Teal** | Fresh, professional, approachable | Customer-facing decks, partnerships |
| **Sage** | Calm, premium, editorial | Strategy docs, research presentations |
| **Cherry** | Bold, energetic, high-contrast | Sales decks, event presentations |

Specify the theme in your request: `"Use the Executive theme"` or let Opulent select the best fit based on the deck type.

---

## Common Uses

### Business & Strategy
- Board updates and quarterly reviews
- Investor pitch decks and fundraising materials
- Strategic planning and roadmap presentations
- OKR reviews and goal-setting presentations

### Sales & Marketing
- Sales decks customized per prospect
- Product launch presentations
- Partnership proposals
- Conference and event talks

### Research & Analysis
- Market research findings
- Competitive landscape reviews
- Industry trend reports
- Product analysis and recommendations

### Technical
- Architecture overviews
- Engineering roadmaps
- System design presentations
- Incident post-mortems

---

## Combining Slides with Data

When connectors are active, Opulent pulls live data into slides automatically:

```
"Create a monthly business review deck. Pull:
- MRR and growth from Stripe
- Pipeline and closed deals from HubSpot
- Open bugs and deployments from GitHub
- Team velocity from Linear
Include a chart for each metric. Executive theme."
```

The agent queries each source, generates charts, and embeds them as slide content — no copy-paste from BI tools required.

---

## Present Mode

Click **Present** in the Slides panel to enter full-screen presentation mode:
- Left/right arrow keys or click to navigate slides
- Speaker notes visible in a second window (Coming soon)
- Share a link for remote viewing (Coming soon)

---

## Tips for Better Decks

Be specific about length and structure:
- ✅ `"10 slides: problem (1), solution (2-3), market (4), traction (5-6), team (7), ask (8), appendix (9-10)"`
- ❌ `"Make a pitch deck"`

Specify the audience:
- ✅ `"For Series A investors who understand SaaS metrics"`
- ✅ `"For a non-technical executive audience"`

Reference your data sources:
- ✅ `"Use the Stripe data from Q4 2025 and our roadmap from Notion"`

Ask for iteration, not regeneration:
- ✅ `"Change the headline on slide 4 to focus on ROI"`
- ✅ `"Add a competitor comparison table to slide 6"`
- ✅ `"Make the content on slide 8 more concise — 3 bullets max"`

---

## Common Questions

**Can I export slides to PowerPoint or PDF?**
Export options are available via the Export button in the Slides panel. PDF export is fully supported. PPTX export is on the roadmap.

**Can I upload my own images to use on slides?**
Yes. Upload images via the file attachment, then reference them: `"Use the logo I uploaded on the title slide"`.

**How many slides can a deck have?**
No hard limit. Decks of 30+ slides are supported. For very long decks, break into sections for best results.

**Can I specify exact slide content?**
Yes. Provide a detailed outline: `"Slide 1: Title slide with our logo. Slide 2: Problem — 3 bullet points about..."` — the agent follows it precisely.

**Can the agent update an existing deck?**
Yes. With a deck already in the Slides panel: `"Add two more slides at the end covering competitive moats"` or `"Rewrite slide 5 from scratch"`.

---

## Parallel Research

**URL:** https://opulent-docs.vercel.app/docs/features/parallel-research
**Description:** Parallel Research - Opulent documentation

# Parallel Research

> Multi-agent parallel processing for large-scale research, analysis, and production tasks

## What is Parallel Research?

Parallel Research is Opulent's approach to tasks that involve processing many similar items — researching 100 companies, analyzing 50 documents, generating 30 pieces of content, or extracting data from 200 pages. Instead of a single agent working sequentially, Opulent deploys independent subagents that work simultaneously, each with its own full context window.

This architecture eliminates the quality degradation that causes most AI systems to produce generic, compressed results after the first 8–10 items.

---

## The Context Window Problem

Traditional AI systems operate with a fixed context window. When asked to process many items sequentially:

- **Items 1–5**: Detailed, thorough analysis with full context available
- **Items 10–20**: Descriptions become shorter as context fills
- **Items 30+**: Generic summaries, errors, and fabrications as earlier context is compressed

Research shows this "fabrication threshold" typically occurs around item 8–10 for most AI systems.

---

## How Parallel Research Works

Opulent uses a fundamentally different architecture:

1. **Task Decomposition** — The orchestrating agent analyzes your request and breaks it into independent sub-tasks (`"research company #1"`, `"research company #2"`, etc.)
2. **Parallel Agent Deployment** — Each sub-task is assigned to a dedicated subagent with its own fresh context window
3. **Independent Processing** — Subagents work simultaneously, each conducting thorough research without competing for context space
4. **Result Synthesis** — The orchestrator collects all completed sub-tasks and assembles them into your requested format

**Result:** Item #200 receives the same depth of analysis as item #1, because each has its own dedicated agent and full context window.

---

## Quick Start

### Simple Request

```
"Research the top 20 enterprise SaaS companies and create a table
with their ARR, founding year, key differentiator, and pricing model"
```

### Detailed Request

```
"Compare 100 B2B startup landing pages. For each, extract: company name,
target ICP, primary value proposition, pricing model, and trial CTA.
Organize in a sortable spreadsheet."
```

### Creative Request

```
"Find 25 prominent venture capitalists. Generate a professional profile
for each including investment thesis, portfolio highlights, and contact
approach. Consistent format throughout."
```

---

## Real Examples

### Example 1: Researching 250 Enterprise Accounts

```
"Research these 250 accounts from our CRM. For each, find: recent funding,
headcount growth, tech stack, and any leadership changes in the past 6 months.
Output as a CSV ready to import back into Salesforce."
```

Output: Complete database with 250 detailed profiles, consistent quality across all entries.

**Why This Works:**
- Each account gets a dedicated subagent with full context
- No quality degradation from account #1 to #250
- Structured output automatically formatted for CRM import

---

### Example 2: Competitive Intelligence at Scale

```
"Analyze all 80 companies in this competitor list. For each, extract:
pricing page URL, pricing tiers, features per tier, free trial availability,
and enterprise contact method. Create a comparison matrix."
```

Output: Comprehensive competitive matrix with 80 rows, all fields populated.

**Why This Works:**
- Parallel browsing across 80 sites simultaneously
- Structured data extraction applied consistently
- No AI fatigue or quality shortcuts on later items

---

### Example 3: Lead Research at Scale

```
"Research these 200 prospects. For each, find: LinkedIn profile URL,
current title and company, years in role, company size, and a 1-sentence
personalization hook for outreach. Output as CSV."
```

Output: 200-row enriched lead list with personalization hooks.

---

### Example 4: Batch Content Generation

```
"Generate 30 LinkedIn posts for our company — one for each topic in this list.
Each post should be 150–200 words, include a hook, value insight, and CTA.
Consistent brand voice throughout."
```

Output: 30 complete, distinct posts with consistent quality. No copy-paste between items.

---

### Example 5: Academic Literature Review

```
"Review these 40 research papers on LLM reasoning. For each, extract:
methodology, key findings, sample size, limitations, and citation count.
Identify patterns and write a synthesis section."
```

Output: Structured literature database + a synthesized narrative across all 40 papers.

---

## Use Cases by Category

| Category | Example Tasks |
|---|---|
| Market Research | Compare 100 products, analyze competitor pricing, survey customer reviews |
| Academic Research | Literature review of 50 papers, compare methodologies, identify citation networks |
| Competitive Intelligence | Profile 50 competitors, track feature sets, monitor pricing changes |
| Lead Generation | Research 200 prospects, find contact info, generate personalization hooks |
| Content Creation | Write 30 blog outlines, generate 50 social posts, produce 20 product descriptions |
| Data Extraction | Scrape 100 websites, extract structured data, compile databases |
| Creative Production | Generate 30 custom images, edit 50 photos, create consistent brand assets |
| Investment Research | Analyze 40 startups, compare 30 funds, profile 50 portfolio companies |
| HR & Recruiting | Screen 100 resumes, research 50 candidates, benchmark 30 job descriptions |

---

## Parallel Research vs. Standard Agent

| Aspect | Standard Agent | Opulent Parallel Research |
|---|---|---|
| Approach | Single agent, sequential processing | Parallel multi-agent orchestration |
| Speed | Hours until context saturation | Minutes regardless of scale |
| Scale | Degrades beyond 8–10 items | Scales to hundreds uniformly |
| Quality | Progressive degradation | Consistent quality at any scale |
| Output | Compressed summaries with detail loss | Complete reports and full datasets |
| Cost | Lower for small tasks | Optimized for large-scale tasks |

---

## When to Use Parallel Research

**Perfect for:**
- Batch processing (50+ similar items)
- Data extraction from 100+ pages or profiles
- Content generation at scale (20+ distinct items)
- Lead research (100+ prospects)
- Competitive intelligence (30+ competitors)
- Literature reviews (20+ papers)

**Not ideal for:**
- Tasks with fewer than 10 items (use standard mode)
- Real-time interactive research requiring your input between steps
- Tasks with deep sequential dependencies (output of step A is input of step B)
- Single deep-dive analysis (use standard agent mode)

---

## Tips for Better Results

Be specific about structure:
- ❌ `"Research these companies"`
- ✅ `"Create a table with columns: company name, ARR, HQ, CEO, founding year, and latest funding round"`

Specify the scale upfront:
- ❌ `"Analyze some of these companies"`
- ✅ `"Analyze all 100 companies in this spreadsheet"`

Describe the desired output format:
- ❌ `"Give me the results"`
- ✅ `"Organize in a CSV with headers matching our Salesforce import format"`

Include evaluation criteria:
- ❌ `"Compare these products"`
- ✅ `"Rate each on: pricing competitiveness, feature depth, ease of integration, and G2 rating"`

---

## Common Questions

**How many items can Parallel Research handle?**
Tested reliably to 250+ items. Practical limits depend on task complexity and available concurrency.

**How long does it take?**
Typically minutes for 50–100 items, regardless of per-item depth. Parallel execution means total time is roughly equal to the time for one item.

**Can I refine results after?**
Yes. Ask for modifications: `"Re-research items 40–60 with more detail"` or `"Add a funding date column for all rows"`.

**Does it work for non-research tasks?**
Yes. Any task involving many independent items: image generation, content writing, data extraction, document analysis.

**How do I trigger it?**
Simply describe your task at scale. Opulent automatically detects when parallel orchestration is the right approach.

---

## Scheduled Tasks

**URL:** https://opulent-docs.vercel.app/docs/features/scheduled-tasks
**Description:** Scheduled Tasks - Opulent documentation

# Scheduled Tasks

> Automate recurring work — run any agent task on a schedule or trigger it from an external event

Scheduled Tasks let you automate recurring work by having Opulent execute tasks on a schedule. Set it once, and Opulent handles it automatically — daily reports, weekly research, monthly analysis, or any recurring workflow.

---

## Quick Start

### One-Time Task

```
"At 3 PM today, pull this week's Stripe revenue numbers and
send a summary to the #finance Slack channel"
```

### Recurring Task

```
"Every Monday at 8 AM, research last week's top AI news,
summarize the 5 most important developments, and email it to our team"
```

### Complex Schedule

```
"On the 1st of every month at 9 AM: query our Stripe and HubSpot accounts,
generate a combined revenue + pipeline report, create a slide deck,
and post it to the #leadership Slack channel"
```

---

## When to Use Scheduled Tasks

**Use for:**
- Automated monitoring (checking for updates, tracking changes)
- Periodic data collection (scraping prices, tracking competitor moves)
- Regular reports (monthly analytics, weekly performance summaries)
- Recurring research (daily news digests, weekly competitor updates)
- Automated alerts (price changes, new funding announcements, social mentions)

**Don't use for:**
- Real-time monitoring (scheduled tasks run at defined times, not continuously)
- One-off tasks you need right now (just run them normally)
- Tasks that require your interactive input mid-execution

---

## Quick Examples

### Example 1: Daily News Digest

```
Schedule: Every weekday at 7 AM
Task: "Search for the top 5 AI and SaaS news stories from the last 24 hours.
      Write a 3-sentence summary of each. Deliver as a formatted email."
Output: Email to your inbox before you start work
```

### Example 2: Weekly Competitor Tracking

```
Schedule: Every Friday at 5 PM
Task: "Check pricing pages for our 10 top competitors. Flag any changes
      since last week. Update the comparison spreadsheet in Google Drive."
Output: Updated comparison doc + Slack notification if changes detected
```

### Example 3: Monthly Revenue Report

```
Schedule: 1st of every month at 9 AM
Task: "Pull MRR, churn rate, new customers, and top 10 accounts from Stripe.
      Combine with pipeline data from HubSpot. Generate a slide deck.
      Post to #leadership in Slack."
Output: Full slide deck posted to Slack automatically
```

### Example 4: Real-Time Lead Alert

```
Schedule: Every day at 9 AM and 3 PM
Task: "Search for new LinkedIn posts mentioning our product name or our
      top 3 competitors. Compile leads who posted and qualify each.
      Notify the sales team via Slack for anyone showing buying intent."
Output: Slack message with qualified prospect list
```

---

## How to Set Up

**Step 1: Describe the task**

Be specific about what the agent should do, what data sources to query, and what to do with the results.

**Step 2: Specify the schedule**

- `"Tomorrow at 3 PM"` — one-time
- `"Every weekday at 7 AM"`
- `"Every Monday at 8 AM"`
- `"On the 1st of every month at 9 AM"`
- `"Every day at 9 AM and 4 PM"`
- `"Every Tuesday and Thursday at 2 PM"`

**Step 3: Define the output**

- Post to Slack channel
- Send via email
- Update a Google Sheet
- Save report to AI Drive
- Create/update a Document in the workspace
- Push to Notion database

---

## Schedule Options

| Schedule Type | Example | Use Case |
|---|---|---|
| Daily | `"Every day at 9 AM"` | News summaries, daily metrics |
| Weekdays | `"Every weekday at 8 AM"` | Business reports, morning briefs |
| Weekly | `"Every Monday at 10 AM"` | Weekly reviews, competitor tracking |
| Monthly | `"On the 1st at 9 AM"` | Monthly reports, billing analysis |
| Multiple per day | `"At 9 AM and 4 PM"` | Price monitoring, social mentions |
| Custom | `"Every Tue and Thu at 2 PM"` | Recurring team cadences |
| One-Time | `"Tomorrow at 3 PM"` | Delayed execution |

---

## Trigger Types

Beyond time-based scheduling, Opulent workflows can be triggered by:

🕐 **Cron** — Run on any schedule (daily, weekly, monthly, custom)
🔔 **Webhook** — Trigger from any external system via HTTP POST
⚡ **Connector Event** — Trigger when something happens in Stripe, GitHub, Slack, etc.
✋ **Manual** — User or another agent triggers on demand

### Webhook Trigger Example

```
"When a new row is added to this Google Sheet,
run a research task on that company and email the enriched data back"
```

### Connector Event Example

```
"When a new deal closes in Salesforce (stage = 'Closed Won'),
automatically send a personalized success email, create a Notion
onboarding page, and post a congrats message to #wins in Slack"
```

---

## Managing Scheduled Tasks

**View active schedules:** Go to Dashboard → Workflows → Scheduled to see all active tasks.

**Pause a schedule:** Toggle off any schedule temporarily without deleting it.

**Edit a schedule:** Modify the timing, task description, or output method.

**Delete a schedule:** Remove schedules you no longer need.

**View execution history:** See past runs, results, output files, and any errors.

---

## Tips for Better Scheduled Tasks

Be specific about timing:
- ❌ `"In the morning"`
- ✅ `"Every weekday at 8 AM EST"`

Define clear outputs:
- ❌ `"Let me know what you find"`
- ✅ `"Post to Slack #team-updates channel"`
- ✅ `"Email me a 5-bullet executive summary"`

Include time ranges for research tasks:
- ❌ `"Recent news"` (ambiguous)
- ✅ `"News from the past 24 hours"`
- ✅ `"Updates since last Monday"`

Test before scheduling:
- Run the task manually once to verify it works exactly as expected
- Then set up the recurring schedule

Use connectors for richer outputs:
- Combine with Slack, email, Google Drive, and Notion connectors for automatic delivery
- The agent doesn't just run — it delivers results exactly where your team needs them

---

## Quick Use Cases

| Use Case | Schedule | Output |
|---|---|---|
| AI & Industry News | Daily 7 AM | Email digest |
| Competitor Tracking | Weekly Friday 5 PM | Google Drive report |
| Social Mentions | Daily 9 AM | Slack notification |
| Revenue Analytics | Monthly 1st day | Slide deck |
| Price Monitoring | Daily 6 AM | Spreadsheet update |
| Lead Pipeline Review | Weekly Monday 8 AM | Salesforce enrichment |
| Customer Churn Signals | Daily 10 AM | Slack alert if threshold hit |
| Content Calendar | Weekly Sunday 10 PM | Notion doc for next week |

---

## Common Questions

**Can I schedule tasks that require connector access?**
Yes. If the agent has been authorized to access Stripe, HubSpot, Slack, or any other connector, scheduled tasks use those same credentials automatically.

**What happens if a scheduled task fails?**
You receive a notification with the error details. Opulent retries automatically for transient failures. Persistent errors are escalated to you.

**Can a scheduled task create other scheduled tasks?**
Yes. Agents can trigger workflows and spawn sub-tasks as part of their execution.

**How do I know when a scheduled task ran?**
All executions appear in the Workflow run history. If you've set up delivery to Slack or email, you'll receive the output directly.

**Can I share a schedule with my team?**
Yes. Scheduled tasks tied to a workspace thread are visible to all workspace members with access.

---

## Sheets

**URL:** https://opulent-docs.vercel.app/docs/features/sheets
**Description:** Sheets - Opulent documentation

# Sheets

> An integrated spreadsheet environment for native data manipulation and visualization alongside your chat.

## What is Sheets?

When agents pull data—whether from your CRM, marketing platforms, or web scraping—outputting raw CSVs or markdown tables into the chat stream quickly becomes unreadable and hard to manipulate. 

Opulent's **Sheets** feature provides a persistent, full-featured spreadsheet interface mounted directly inside the workspace UI. It allows your agents to seamlessly dump, format, and synthesize tabular data while giving you the power to interact with it just like a traditional spreadsheet application.

---

## Capabilities

### Native Data Operations
Agents don't just paste data; they interact with the sheet programmatically. You can ask an agent to:
- `"Pull all active subscriptions and dump them into the Sheet"`
- `"Filter the Sheet to only show customers with MRR > $500"`
- `"Add a new column that calculates the percentage change from last month"`

### Live Visualization
The Sheets panel includes integrated charting capabilities. Instead of relying on an external BI tool, you can instruct the agent to visualize the data currently loaded in the sheet.
- `"Create a bar chart comparing Q3 vs Q4 revenue based on this sheet."`
- `"Generate a line chart showing daily active users over the last 30 days."`
The charts are rendered instantly as artifacts next to the tabular data.

### Persistent Context
Because Sheets are tied directly to your persistent Workspace environment, the data remains available across sessions. If you pull a competitor matrix on Tuesday, you can ask the agent to add a new competitor to the existing sheet on Thursday without having to scrape all the data again.

---

## Workflow Example: Pipeline Review

1. **Extraction:** `"Connect to Salesforce and pull all deals closing this quarter into the Sheet."`
2. **Refinement:** `"Highlight any rows in red where the 'Last Contacted' date is more than 14 days ago."`
3. **Synthesis:** `"Generate a summary report of the total pipeline value grouped by Sales Rep, and insert a pie chart."`
4. **Export:** Once the data is perfect, you can manually export it as a pristine CSV or hand it off to another subagent (e.g., an Email subagent to blast the report to the team).

---

## Why Integrated Sheets Matter

By keeping data manipulation inside the Opulent environment:
- You eliminate the constant context-switching of downloading CSVs, opening Excel, and re-uploading modified data.
- The agent maintains full **Data Provenance**. It knows exactly where the data came from and the transformations applied to it.
- You empower the agent to act as a complete data analyst, spanning extraction, transformation, visualization, and reporting in a single unified interface.

---

## Slash Commands

**URL:** https://opulent-docs.vercel.app/docs/features/slash-commands
**Description:** Slash Commands - Opulent documentation

# Slash Commands

> Instant access to powerful agent behaviors — type / and choose exactly how you want the agent to work

## What it is

Slash Commands are one-keystroke shortcuts that change how the agent approaches your task. Type `/` in the chat input to open the command menu, select a command, and the agent operates with that mode active — planning before acting, thinking harder, fact-checking claims, storing to memory, and more.

They are the fastest way to move from free-form chat to directed, structured agent behavior.

---

## How to Use

1. Type `/` at the start of your message in the chat input
2. The command menu appears above the input
3. Continue typing to filter: `/pl` shows `/plan`, `/plot`, `/playback`
4. Arrow keys navigate, Enter or Tab selects, Escape dismisses
5. Click any command to select it directly

After selecting, the command's instruction prefix is injected into your message. Describe your task as usual — the command modifies how the agent handles it.

---

## Built-in Commands

### Planning & Thinking

| Command | What It Does |
|---|---|
| `/plan` | Creates a detailed step-by-step plan before doing any work. Presents the plan and waits for your approval. |
| `/think-hard` | Triggers deep analysis mode — multiple approaches, trade-offs, second-order effects — before responding. |
| `/research` | Conducts thorough multi-source research with cross-referenced findings and citations. |

### Implementation

| Command | What It Does |
|---|---|
| `/implement` | Requests a full, production-quality implementation — not a scaffold or stub. |
| `/build` | Builds end-to-end: architecture, code, tests, working deliverable. |
| `/automate` | Designs and builds a repeatable automation workflow — robust, documented, re-runnable. |
| `/debug` | Systematically debugs an issue — hypothesizes causes, tests each, fixes the root cause. |

### Quality & Review

| Command | What It Does |
|---|---|
| `/review` | Reviews code or content for correctness, completeness, security, and quality. Specific, actionable findings. |
| `/test` | Writes comprehensive tests — happy path, edge cases, error conditions. |
| `/fact-check` | Verifies all claims against reliable sources. Flags inaccuracies with corrections. |

### Output & Memory

| Command | What It Does |
|---|---|
| `/enhance` | Significantly improves an existing piece of work — clarity, depth, structure, professionalism. |
| `/summarize` | Creates a concise, well-structured summary. Key points only, well-organized. |
| `/analyze` | Deep analysis of data, code, or content — patterns, anomalies, root causes, insights. |
| `/remember` | Stores key information to agent memory so it's available in all future conversations. |

---

## Examples

### Using /plan

```
/plan Build a Stripe webhook integration that handles subscription lifecycle events
```

The agent responds with a detailed implementation plan covering every step — database schema, webhook handlers, event types, error handling, testing approach — and waits for your approval before writing any code.

---

### Using /think-hard

```
/think-hard Should we build our own auth or use Clerk?
```

The agent works through both options systematically — cost, maintenance, security, time-to-market, lock-in risk, team capability — before presenting a reasoned recommendation.

---

### Using /review

```
/review [paste code or describe what to review]
```

The agent reviews for bugs, edge cases, security vulnerabilities, performance problems, and code quality. Each finding is specific with a concrete suggested fix.

---

### Using /remember

```
/remember Our fiscal year runs February to January. We use Linear for sprint tracking. Our primary database is Convex on the production deployment artful-fly-108.
```

The agent stores this to your memory block. All future interactions — including scheduled tasks and workflows — have access to this context automatically.

---

### Using /research

```
/research What are the main regulatory requirements for deploying AI agents in financial services in the US and EU?
```

The agent searches multiple sources, cross-references findings, identifies consensus and gaps, and produces a structured, cited report.

---

## Custom Commands

Create your own slash commands to capture your team's most-used workflows.

### Creating a Custom Command

1. Go to **Dashboard → Agents → Slash Commands**
2. Click **New command**
3. Give it a name (e.g., `competitor-brief`)
4. Write a description
5. Write the prompt template — use `$ARGUMENTS` where your task text should be inserted

**Example: `/competitor-brief`**

```
Command: competitor-brief
Description: Generate a structured competitor brief

Prompt Template:
Research the following company thoroughly for competitive intelligence purposes.
Include: company overview, product features, pricing, ICP, key differentiators,
known weaknesses, recent news, and a recommended approach for competing against them.
Output as a structured brief in the Document panel.

Company: $ARGUMENTS
```

Now typing `/competitor-brief Salesforce` triggers that full research prompt automatically.

---

## Managing Commands

Visit **Dashboard → Agents → Slash Commands** to:

- View all built-in commands with their prompt templates (expandable)
- Create new custom commands
- Edit your custom commands
- Delete custom commands you no longer need

Built-in commands are read-only but can be inspected — click any command row to see the full prompt template it injects.

---

## Tips

**Use `/plan` for any task you're not fully sure about.** Getting a plan back before implementation lets you catch misunderstandings early — before the agent spends 20 minutes building the wrong thing.

**Use `/remember` for anything you say more than once.** If you've explained your tech stack, naming conventions, or team preferences before, tell the agent to remember them. You shouldn't have to repeat yourself.

**Chain commands in sequence.** For complex work: start with `/plan`, approve the plan, then follow up with `/implement`. Or: `/research` the landscape, then `/analyze` what you've found, then `/build` the solution.

**Build a custom command for every recurring workflow.** If your team does the same type of task repeatedly — competitor briefs, PR descriptions, sprint recaps — create a command that captures the template and shares it across your workspace.

---

## Common Questions

**Do slash commands consume extra credits?**
No. Commands modify how the agent processes your request but don't add overhead billing.

**Can I use slash commands in scheduled tasks?**
Not directly — scheduled tasks use full natural language instructions. But you can copy a command's prompt template directly into a scheduled task description.

**Can my whole team use the same custom commands?**
Custom commands are currently stored per user in the browser. Workspace-level shared commands are on the roadmap.

**Can I override a built-in command?**
Not directly — built-in commands cannot be deleted. But you can create a custom command with a similar name (e.g., `plan-v2`) that uses your preferred template.

**What's the difference between `/plan` and just asking "make a plan first"?**
Functionally similar. `/plan` is a one-keystroke shortcut that ensures the exact planning instruction is applied consistently every time, without you having to remember the phrasing.

---

## Subagents

**URL:** https://opulent-docs.vercel.app/docs/features/subagents
**Description:** Subagents - Opulent documentation

# Subagents

> Multi-agent orchestration for delegating complex, specialized workloads

## What are Subagents?

Instead of relying on a single monolithic agent to handle every aspect of a complicated objective, Opulent utilizes a **Subagent Architecture**. 

When you give Opulent a complex task, the primary agent acts as an **Orchestrator**. It breaks down the problem, plans the execution, and then dynamically spins up specialized "subagents" to handle the individual components. These subagents act in isolation, focusing entirely on their narrow tasks, and return their results to the orchestrator for synthesis.

---

## Why Subagents Matter

Asking one agent to write code, design a UI, research competitors, and format a presentation in a single pass leads to context confusion and poor results. Subagents solve this:

- **Specialization:** Subagents can be strictly prompted for specific roles (e.g., an "Explorer" subagent built just for web scraping, or a "Coder" subagent built strictly for resolving typescript errors).
- **Parallel Execution:** The orchestrator can spin up 10 subagents simultaneously to research 10 different companies, turning 2 hours of sequential work into 5 minutes of parallel work.
- **Context Isolation:** A subagent researching competitors doesn't need the codebase context in its window, keeping its token usage low and its reasoning sharp.

---

## How It Works

### 1. Decomposition and Planning
The Orchestrator agent analyzes your request. If the task is simple, it may handle it directly. If complex, it creates an execution graph.

### 2. Subagent Spawning
The Orchestrator spawns specialized subagents and delegates the sub-tasks. Each subagent is given:
- A specific, narrow objective.
- Only the precise context it needs.
- Access to specific tools (a web-scraper subagent doesn't need file-writing tools).

### 3. Execution & Verification
Subagents execute their tasks. They can autonomously verify their own work (e.g., a coder subagent running a linter) before returning the result.

### 4. Synthesis
The Orchestrator collects the outputs from all subagents, resolves any conflicts, synthesizes the final result, and presents it to you.

---

## Example Subagent Topologies

### Software Development Topology
```
"Build a new authentication flow for the frontend."
```
1. **Orchestrator:** Plans the changes needed.
2. **Researcher Subagent:** Reads the UI component library docs and existing auth state.
3. **Coder Subagent:** Writes the new React components in the sandbox.
4. **Verifier Subagent:** Runs the test suite and attempts to log in using the Cloud Browser Infrastructure, reporting any visual bugs back to the Coder.

### Competitive Intelligence Topology
```
"Compile a feature comparison of our top 5 competitors."
```
1. **Orchestrator:** Identifies the 5 competitors.
2. **Explorer Subagents (x5):** Spins up 5 parallel subagents. Each navigates to one competitor's website, extracts the pricing and feature lists, and structures the data.
3. **Orchestrator:** Takes all 5 structured JSON objects, compares them, and generates the final matrix.

---

## Managing Subagents

While subagents operate autonomously, you maintain full visibility.
- **Live Monitoring:** The Opulent dashboard shows the active orchestrator plan and the real-time status of all running subagents.
- **Granular Control:** If a specific subagent struggles or asks for clarification, you can interact with it directly without derailing the other subagents.
- **Resource Limits:** Administrators can set limits on how many subagents an orchestrator can spawn simultaneously to manage computational budgets.

---

## Workspaces

**URL:** https://opulent-docs.vercel.app/docs/features/workspaces
**Description:** Workspaces - Opulent documentation

# Workspaces

> Persistent, context-aware environments — every new task starts knowing exactly what it needs to know

## What it is

Opulent Workspaces are persistent environments that retain instructions, knowledge, memory, and file context across every task. Backed by **Secure Sandboxing**, these environments offer complete isolation with full repository (Git) access and state snapshots. Instead of re-explaining your business context or setting up local dev environments each time, a workspace carries that context automatically — from the first task to the hundredth.

Workspaces replace the need for repetitive setup. Define a context once, and every agent interaction in that workspace starts from a fully informed, securely isolated position.

---

## How to Create a Workspace

1. Open the Dashboard and click **New Workspace**
2. Give it a name and write a master instruction that defines the context, goals, and constraints
3. Upload relevant files to the knowledge base (SOPs, brand guides, codebase docs, product specs)
4. Start creating tasks — each one automatically inherits the workspace configuration

### Secure Execution & Snapshots

Every workspace operates in a secure sandbox. This isn't just a container; it includes:
- **Full Repository Access:** Agents can initialize Git repos, create branches, commit code, and push to remote origins natively.
- **State Snapshots:** Workspaces can be captured and restored, meaning long-running projects can be paused and resumed exactly where the agent left off, down to the filesystem level.

### Pinning Workspaces

Pin frequently used workspaces to the top of your sidebar. Hover over any workspace and click the pin icon. Pinned workspaces always appear first, regardless of sort order.

---

## Master Instructions

The master instruction is the always-on system context for every task in the workspace. Write it to contain everything the agent needs to operate without repeated explanation.

### What to Include

**Identity & Purpose**
```
"This workspace is for the Acme Corp Growth team. The agent's role is
to support outbound research, competitive analysis, and content production.
Always maintain a professional, data-driven tone."
```

**Naming Conventions & Standards**
```
"File naming: YYYY-MM-DD_ProjectName_Version.
All reports should use the Executive slide theme.
Data tables should always include a 'Source' column."
```

**Constraints & Rules**
```
"Never include specific revenue figures in external-facing documents.
All research should cite at least 3 independent sources.
Competitors: Salesforce, HubSpot, Pipedrive."
```

**Tooling Preferences**
```
"Prefer Google Drive for file delivery. Slack #growth-team for notifications.
Use HubSpot as the source of truth for pipeline data."
```

---

## Knowledge Base

Upload files that should be available as reference for every task in the workspace.

### What to Upload

| File Type | Use Case |
|---|---|
| Brand guide (PDF) | Ensure consistent tone and style in all outputs |
| Product spec sheet | Keep agents accurate on features, pricing, positioning |
| Competitor matrix | Inform competitive positioning in every research task |
| SOP documents | Guide agent behavior in recurring workflows |
| Codebase README | Provide context for development tasks |
| Customer personas | Ensure outputs are audience-appropriate |
| Previous reports | Provide baseline for comparisons and updates |

### Knowledge Base Updates

- **File updates** take effect in new tasks created after the update
- **Instruction updates** apply the next time you send a message in any task
- Previously completed tasks are not affected by updates

---

## Memory

Beyond static files, Opulent's memory system creates compounding context across every interaction in the workspace.

Agents automatically store:
- Project decisions and rationale
- Your stated preferences (formatting, tone, tooling)
- Key facts about your business, team, and customers
- Patterns from past tasks (what worked, what to avoid)

This means a workspace that has been active for 30 days knows far more than one created today — and that knowledge compounds with every subsequent task.

### Managing Memory

```
"Remember that our fiscal year runs February to January"
"Store this competitor analysis in memory for future reference"
"Update memory: we now use Linear instead of Jira for sprint tracking"
```

View and manage stored memory blocks from the workspace Settings → Memory panel.

---

## Collaboration

Workspaces are private by default. Share with teammates to enable collaborative agent workflows.

### Sharing Model

| What is Shared | How |
|---|---|
| Master instructions | Automatically shared with all workspace members |
| Knowledge base files | Automatically shared with all workspace members |
| Agent memory | Shared at workspace level |
| Individual task threads | Private to creator by default — share explicitly |

To share a specific task thread with a colleague, open the thread and use the Share button.

---

## Organizing Tasks

Within a workspace, use filters to navigate your work:

| Filter | Shows |
|---|---|
| All tasks | Every task in the workspace |
| In progress | Currently active agent tasks |
| Scheduled | Tasks queued for future execution |
| Completed | Finished tasks with outputs |

Drag tasks to reorder them. Mark favorites for quick access.

---

## Tips

**Write detailed master instructions.** The more specific your context, the less you need to repeat per task. Think of it as onboarding the agent to your team once.

**Keep the knowledge base current.** Outdated docs produce outdated outputs. Review your knowledge base monthly and replace stale files.

**Use one workspace per team function.** Separate workspaces for Sales Research, Product Development, and Finance keep context clean and relevant — agents don't carry irrelevant context from unrelated projects.

**Let memory accumulate.** The longer a workspace is active, the more context the agent carries. Don't reset unnecessarily.

**Test the master instruction with a real task.** After writing instructions, run a representative task to verify the agent behavior matches your expectations.

---

## Common Questions

**Is there a limit on how many workspaces I can create?**
No limit. Create as many as your workflow requires.

**Can I invite someone to see only specific tasks, not the whole workspace?**
Yes. Individual tasks can be shared separately from the workspace itself.

**If I update the master instruction, does it affect ongoing tasks?**
Instruction updates apply the next time you send a message in any active task. Tasks you don't interact with again won't see the update until reactivated.

**Can I move a standalone task into a workspace?**
Yes. Tasks can be moved into workspaces at any time.

**Can the agent from one workspace access memory from another?**
No. Memory is scoped to the workspace. This keeps contexts clean and prevents contamination across projects.

---

## Opulent API

**URL:** https://opulent-docs.vercel.app/docs/integrations/api
**Description:** Opulent API - Opulent documentation

# Opulent API

> Programmatic access to Opulent as a complete AI agent — not just text generation, but full task execution

## What is the Opulent API?

The Opulent API is a RESTful API that gives developers programmatic access to the full Opulent agent. Instead of calling an endpoint and getting a text completion back, you send a task, and Opulent plans the approach, uses tools, browses the web, queries your data, writes and runs code, and delivers a complete result.

This is the difference between an AI API and an AI agent API.

---

## Why the Opulent API is Different

**Traditional AI API:**
- Send a prompt → receive a text response
- Model has no tools, no memory, no ability to act

**Opulent API:**
- Send a task → agent plans, executes, delivers
- Agent has: browser, code execution, connectors, memory, file system
- Output can be: a report, a slide deck, a populated spreadsheet, deployed code, a Notion page, a Slack message

```python
# Traditional AI API
response = openai.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Research Acme Corp"}]
)
# Returns: text about how it would research Acme Corp

# Opulent API
task = opulent.tasks.create(
    prompt="Research Acme Corp — funding, headcount, products, recent news. Deliver as a structured brief.",
    connectors=["web_search", "crunchbase"],
    output={"slack_channel": "#sales-prep"}
)
# Returns: task_id
# Agent actually researches, synthesizes, and posts to Slack
```

---

## Quick Start

### Install the SDK

```bash
npm install @opulentia/sdk
# or
pip install opulentia
```

### Create a Task

```typescript

const client = new Opulent({ apiKey: process.env.OPULENT_API_KEY });

const task = await client.tasks.create({
  prompt: 'Research the top 10 enterprise AI platforms and create a comparison table covering: pricing, key features, target ICP, and G2 rating.',
  connectors: ['web_search'],
  output: { format: 'markdown' }
});

// Poll for completion
const result = await client.tasks.waitForCompletion(task.id);
console.log(result.output);
```

```python
from opulentia import Opulent

client = Opulent(api_key=os.environ["OPULENT_API_KEY"])

task = client.tasks.create(
    prompt="Analyze our Q4 Stripe revenue. MRR, churn, top 10 accounts. Return as JSON.",
    connectors=["stripe"],
    output={"format": "json"}
)

result = client.tasks.wait_for_completion(task.id)
print(result.output)
```

---

## Core Endpoints

### Tasks

| Method | Endpoint | Description |
|---|---|---|
| `POST` | `/v1/tasks` | Create a new task |
| `GET` | `/v1/tasks/{id}` | Get task status and result |
| `GET` | `/v1/tasks` | List all tasks |
| `DELETE` | `/v1/tasks/{id}` | Cancel or delete a task |

### Create Task Request

```json
{
  "prompt": "Research the Series A funding landscape for AI startups in Q4 2025. Identify top 20 rounds, investors, and deal terms.",
  "connectors": ["web_search", "crunchbase"],
  "thread_id": "optional-existing-thread-id",
  "output": {
    "format": "markdown",
    "deliver_to": {
      "slack_channel": "#research",
      "email": "analyst@company.com"
    }
  },
  "options": {
    "model": "accounts/fireworks/models/kimi-k2p5",
    "max_steps": 80
  }
}
```

### Task Response

```json
{
  "id": "task_abc123",
  "status": "completed",
  "created_at": "2026-02-21T19:00:00Z",
  "completed_at": "2026-02-21T19:04:32Z",
  "output": {
    "text": "# Q4 2025 AI Startup Funding Analysis\n\n...",
    "format": "markdown",
    "files": [
      {
        "name": "funding-analysis.md",
        "url": "https://..."
      }
    ]
  },
  "usage": {
    "steps": 12,
    "tools_called": 8
  }
}
```

### Threads

Threads maintain conversation context across multiple tasks:

```typescript
// Create a thread for a project
const thread = await client.threads.create({
  title: 'Q4 Investor Research',
  workspace_id: 'ws_abc'
});

// All tasks in this thread share context
await client.tasks.create({
  thread_id: thread.id,
  prompt: 'Research Sequoia Capital portfolio companies'
});

await client.tasks.create({
  thread_id: thread.id,
  prompt: 'Now compare to a16z's portfolio from the same period'
  // Agent remembers the Sequoia research above
});
```

---

## Streaming

For real-time results, use Server-Sent Events:

```typescript
const stream = await client.tasks.stream({
  prompt: 'Write a detailed technical specification for a payment processing microservice'
});

for await (const event of stream) {
  if (event.type === 'tool_call') {
    console.log('Agent using tool:', event.tool);
  }
  if (event.type === 'text_delta') {
    process.stdout.write(event.text);
  }
  if (event.type === 'complete') {
    console.log('\nTask complete');
  }
}
```

---

## Enabling Connectors via API

Specify which connectors the agent can use for a given task:

```json
{
  "prompt": "Pull Q4 MRR from Stripe and update the Notion revenue dashboard",
  "connectors": ["stripe", "notion"],
  "connector_options": {
    "stripe": { "account_id": "acct_xxx" },
    "notion": { "database_id": "db_xxx" }
  }
}
```

Available connector IDs: `stripe`, `salesforce`, `hubspot`, `github`, `slack`, `notion`, `google_drive`, `postgresql`, `snowflake`, `web_search`, `email`, and all others from the [Connectors](../features/ecosystem-connectors) list.

---

## Webhooks (Outbound)

Register a webhook to receive task completion notifications:

```json
POST /v1/webhooks
{
  "url": "https://yourapp.com/opulent-webhook",
  "events": ["task.completed", "task.failed"],
  "secret": "your-signing-secret"
}
```

Opulent will POST to your URL when tasks complete:

```json
{
  "event": "task.completed",
  "task_id": "task_abc123",
  "output": { ... },
  "timestamp": "2026-02-21T19:04:32Z"
}
```

---

## Rate Limits

| Plan | Tasks per minute | Concurrent tasks |
|---|---|---|
| Starter | 10 | 3 |
| Growth | 60 | 20 |
| Enterprise | Custom | Custom |

---

## Use Cases for the API

### Embed Opulent in Your Product

```
User requests a competitive analysis report in your SaaS app
→ Your backend calls Opulent API with the research prompt
→ Opulent researches and produces a formatted report
→ Report displayed to user in your UI
```

### Build Intelligent Internal Tools

```
Slack bot receives a slash command: /briefing COMPANY_NAME
→ Your Slack app calls Opulent API
→ Opulent researches the company
→ Summary posted back to Slack automatically
```

### Automate Reporting Pipelines

```
Cron job runs every Monday
→ Calls Opulent API with weekly report prompt
→ Opulent queries Stripe + HubSpot + GitHub
→ Produces slide deck
→ Posts to leadership Slack channel
```

---

## Authentication

All API calls require a Bearer token:

```bash
curl -X POST https://artful-fly-108.convex.site/api/v1/tasks \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Your task here"}'
```

Get your API key from **Settings → API Keys**.

---

## Common Questions

**Is this the same agent as the web UI?**
Yes. The same agent, the same tools, the same connectors.

**Can I use the API with my own models?**
Enterprise plans support custom model routing. Contact us for details.

**How do I handle long-running tasks?**
Use webhooks to receive completion notifications rather than polling. For real-time updates, use the streaming endpoint.

**Is there a sandbox/test mode?**
Yes. Use the `"test": true` flag in requests. Test tasks run against real agent logic but don't consume production connector quotas.

**Where is the full API reference?**
See [api.opulentia.ai/docs](https://api.opulentia.ai/docs) for the complete OpenAPI specification.

---

## Data Sources

**URL:** https://opulent-docs.vercel.app/docs/integrations/data-sources
**Description:** Data Sources - Opulent documentation

# Data Sources

> Premium third-party data APIs available to all Opulent agents — no API keys or setup required

## What are Data Sources?

Data Sources are premium external data APIs that Opulent has integrated at the platform level. When you need real-time market data, company intelligence, financial information, or content analytics, just mention what you need — Opulent calls the appropriate source automatically.

No API keys. No account setup. No rate limit management. All included with your Opulent subscription.

---

## How to Use Data Sources

Simply describe the data you need in your task. Opulent determines which source to use and calls it automatically.

```
"Get the current stock price and P/E ratio for NVDA, MSFT, and GOOG"
```

```
"Find Acme Corp's funding history, employee count, and investor list"
```

```
"What are the top trending videos on YouTube this week in the AI category?"
```

No connector setup required for these sources — they work immediately.

---

## Available Data Sources

### Company Intelligence

| Source | What It Provides |
|---|---|
| **Crunchbase** | Company profiles, funding rounds, investors, leadership, acquisition history |
| **LinkedIn Data** | Company size, growth trends, employee distribution, recent hires |
| **PitchBook** | Private company valuations, deal terms, investor portfolios |
| **SEC EDGAR** | Public company filings, 10-K, 10-Q, 8-K reports, insider transactions |

**Example:**
```
"Research Anthropic — funding history, valuation, key investors, and headcount growth over the last 2 years"
```

---

### Financial Markets

| Source | What It Provides |
|---|---|
| **Stock Data** | Real-time and historical prices, volume, market cap, P/E ratios |
| **Options Data** | Options chains, implied volatility, put/call ratios |
| **Macro Indicators** | GDP, inflation, unemployment, interest rates by country |
| **ETF & Fund Data** | Holdings, performance, expense ratios |

**Example:**
```
"Compare the 12-month stock performance of NVDA, AMD, and INTC.
Include: price appreciation, P/E ratio, revenue growth, and analyst ratings."
```

---

### Social & Content Analytics

| Source | What It Provides |
|---|---|
| **YouTube Analytics** | Trending videos, channel stats, view counts, engagement |
| **TikTok Trends** | Trending sounds, hashtags, creator stats, video performance |
| **Reddit Data** | Post trends, subreddit analytics, sentiment analysis |
| **Twitter/X Data** | Trending topics, tweet analytics, influencer reach |

**Example:**
```
"Find the top 10 most-viewed YouTube videos about AI agents in the last 30 days.
For each: title, channel, views, and key topics covered."
```

---

### Economic & Market Research

| Source | What It Provides |
|---|---|
| **World Bank** | Global development indicators, country-level economic data |
| **FRED (Federal Reserve)** | US economic data series — 800,000+ time series |
| **IMF Data** | International monetary statistics and forecasts |
| **Industry Reports** | Market size, growth rates, and segment breakdowns by vertical |

**Example:**
```
"What is the current inflation rate, unemployment rate, and Fed funds rate?
How have they trended over the last 12 months?"
```

---

### Web Intelligence

| Source | What It Provides |
|---|---|
| **SimilarWeb** | Website traffic, audience demographics, traffic sources |
| **SEMrush** | Keyword rankings, backlinks, competitive SEO data |
| **BuiltWith** | Technology stack detection for any website |
| **Domain Data** | Whois, SSL certificates, domain age and registration |

**Example:**
```
"Analyze our top 5 competitors' websites — traffic volume, top traffic sources,
and estimated keyword rankings for our 10 target keywords."
```

---

## Combining Data Sources

Data Sources work best when combined with Opulent's analysis and output capabilities:

### Investment Research

```
"Research these 20 AI startups. For each, pull from Crunchbase:
funding history, investors, and team size. Add public financial data
where available. Score each on growth potential and output as a
comparison table in the Sheets panel."
```

### Competitive Intelligence

```
"For our top 10 competitors, pull: SimilarWeb traffic, LinkedIn employee count,
Crunchbase funding, and current tech stack from BuiltWith.
Create a competitive matrix and identify the 3 most vulnerable."
```

### Market Sizing

```
"What is the current TAM for the enterprise AI agent market?
Pull analyst reports and macro data, synthesize into a bottom-up and
top-down estimate, and create a 2-slide market size overview."
```

---

## Notes

- All data sources are included in your Opulent subscription. No additional billing.
- Data freshness varies by source — real-time for financial markets, weekly for company intelligence.
- Rate limits are managed at the platform level. You will not encounter API rate errors.
- For data that requires more current or deeper access than platform sources provide, Opulent's web browsing capability can supplement with live web research.
- Critical business decisions should be verified against primary sources. Opulent surfaces data for analysis and acceleration — not as a replacement for direct verification.

---

## MCP Servers

**URL:** https://opulent-docs.vercel.app/docs/integrations/mcp-servers
**Description:** MCP Servers - Opulent documentation

# MCP Servers

> Connect Opulent to any tool that exposes an MCP interface — internal systems, proprietary APIs, and community tools

## What is MCP?

MCP (Model Context Protocol) is an open standard that lets any tool expose its capabilities to AI agents. If a service has an MCP server, Opulent can connect to it and use its tools without requiring a custom integration.

This means Opulent's connector ecosystem is not limited to what the Opulent team has manually built. As the MCP ecosystem grows — and it's growing fast — Opulent gains new capabilities automatically.

---

## Why MCP Matters

**Pre-built connectors** cover the most common tools. But every organization has:
- Internal tools no one else uses
- Proprietary APIs built in-house
- Niche services with no standard connector
- Legacy systems that don't fit the standard integration model

MCP solves this. Build an MCP server once for any tool, and any MCP-compatible agent — including Opulent — can use it.

---

## Connecting a Public MCP Server

Many popular tools already expose MCP servers. Connect them in minutes:

### From the Connector Panel

1. Go to **Settings → Connectors → MCP Servers → Add Server**
2. Enter the MCP server URL
3. Add any required credentials (API key, token)
4. Click **Connect**

The agent discovers all tools the server exposes and makes them available immediately.

### Community MCP Servers

A growing library of community-built MCP servers is available for:

| Category | Examples |
|---|---|
| Developer Tools | GitHub, GitLab, Jira, Linear, Sentry |
| Data & Analytics | BigQuery, Snowflake, Redshift, dbt |
| Communication | Slack, Discord, Teams |
| Productivity | Notion, Obsidian, Airtable, Coda |
| Infrastructure | AWS, GCP, Azure, Kubernetes |
| Finance | Plaid, Stripe, QuickBooks |
| Custom APIs | Any REST API with an MCP wrapper |

Find available MCP servers at the [MCP Registry](https://mcpregistry.dev).

---

## Building a Custom MCP Server

Connect any internal tool or proprietary API by building a lightweight MCP server.

### What You Need

- A system with tools or data you want Opulent to access
- The ability to run a small HTTP server (Node.js, Python, or any language)
- An MCP SDK (available for Node.js, Python, Go, Rust)

### Example: Internal CRM MCP Server (Node.js)

```typescript

const server = new MCPServer({
  name: 'acme-internal-crm',
  version: '1.0.0'
});

server.addTool({
  name: 'get_customer',
  description: 'Retrieve customer record by ID or email',
  parameters: {
    type: 'object',
    properties: {
      identifier: { type: 'string', description: 'Customer ID or email address' }
    },
    required: ['identifier']
  },
  handler: async ({ identifier }) => {
    const customer = await internalCRM.getCustomer(identifier);
    return { content: [{ type: 'text', text: JSON.stringify(customer) }] };
  }
});

server.addTool({
  name: 'update_customer_status',
  description: 'Update the status field for a customer record',
  parameters: {
    type: 'object',
    properties: {
      customer_id: { type: 'string' },
      status: { type: 'string', enum: ['active', 'churned', 'at_risk', 'vip'] }
    },
    required: ['customer_id', 'status']
  },
  handler: async ({ customer_id, status }) => {
    await internalCRM.updateStatus(customer_id, status);
    return { content: [{ type: 'text', text: `Updated ${customer_id} to ${status}` }] };
  }
});

server.listen({ port: 3100 });
```

Once deployed, add `https://your-internal-domain.com:3100` to Opulent's MCP Servers list. The agent can now read and update your internal CRM.

### Example: Legacy API Wrapper (Python)

```python
from mcp import MCPServer, tool

server = MCPServer("legacy-inventory-system")

@tool(description="Query inventory levels by SKU or product category")
def get_inventory(sku: str = None, category: str = None):
    result = legacy_api.inventory_query(sku=sku, category=category)
    return result.to_dict()

@tool(description="Create a purchase order for restocking")
def create_purchase_order(sku: str, quantity: int, supplier_id: str):
    po = legacy_api.create_po(sku, quantity, supplier_id)
    return {"po_id": po.id, "estimated_arrival": po.eta}

server.run(host="0.0.0.0", port=3200)
```

---

## MCP Server Security

### Authentication

Your MCP server should require authentication. Opulent supports:

- **Bearer tokens** — Standard API key in the Authorization header
- **OAuth 2.0** — For user-level permissions
- **IP allowlisting** — Restrict to Opulent's outbound IPs

### Recommended Security Practices

- Expose only the operations the agent needs — no admin endpoints
- Use read-only credentials where possible for research and analysis tasks
- Log all MCP calls for audit purposes
- Use HTTPS with a valid certificate
- Validate all inputs before passing to your backend systems

---

## What the Agent Can Do with MCP

Once a server is connected, the agent uses its tools naturally in any task:

```
"Check our internal inventory system for all products with stock below
reorder threshold. For each, create a purchase order and notify the
procurement team via Slack."
```

The agent:
1. Calls `get_inventory(category="all")` via your MCP server
2. Filters items below threshold
3. Calls `create_purchase_order(...)` for each
4. Posts summary to Slack via the Slack connector

No code written by you — just a connected MCP server and a natural language instruction.

---

## MCP vs. Direct Connectors

| | Pre-built Connectors | MCP Servers |
|---|---|---|
| Setup time | 2 minutes (OAuth or API key) | 30–60 minutes to build and deploy |
| Tools available | Fixed set per connector | Fully customizable — you define the tools |
| Best for | Standard SaaS tools | Internal systems, proprietary APIs, niche tools |
| Maintenance | Maintained by Opulent | Maintained by you |
| Discovery | Automatic | Agent discovers available tools on connection |

---

## Common Questions

**Does the MCP server need to be publicly accessible?**
It needs to be reachable from Opulent's agent infrastructure. You can use a secure tunnel (e.g., ngrok for development, or a private network connection for production).

**How does Opulent know what tools the server exposes?**
Opulent calls the MCP server's `list_tools` endpoint on connection and caches the tool definitions. The agent uses these definitions to decide when to call each tool.

**Can I restrict which workspaces can use a given MCP server?**
Yes. MCP server connections are scoped per workspace. Enable them selectively.

**Is there a limit on how many MCP servers I can connect?**
No hard limit. Practical limits depend on plan tier.

**Can I use MCP servers in scheduled tasks and webhook-triggered workflows?**
Yes. Any active connector — including MCP servers — is available in automated workflows.

---

## Slack Integration

**URL:** https://opulent-docs.vercel.app/docs/integrations/slack
**Description:** Slack Integration - Opulent documentation

# Slack Integration

> Bring Opulent into your team conversations — tag the agent in any thread and collaborate in real time

## What is Opulent for Slack?

Opulent for Slack brings the full agent directly into your team's Slack workspace. Instead of leaving Slack to run a task, copying results, and pasting them back, you tag `@opulent` in any thread and the agent works right there — reading the thread context, delivering results everyone can see, and iterating based on team feedback.

AI stops being a solo tool and becomes a shared team capability.

---

## Why Slack Integration Matters

Without it:
1. Leave Slack to open Opulent
2. Re-explain the context the team already discussed
3. Copy results back to Slack
4. Teammate asks a follow-up → repeat
5. Two people run overlapping tasks → conflicting outputs

With Opulent in Slack:
- The agent reads the full thread — no re-explanation
- Results appear in the thread where the conversation lives
- The whole team reviews and refines together
- One output, one thread, zero version confusion

---

## How It Works

### 1. Tag @opulent in Any Thread

```
@opulent Based on this discussion, create a brief for our Q1 product roadmap
```

```
@opulent Analyze this competitor's pitch deck and list their top 3 claims we should counter
```

```
@opulent Pull our Stripe MRR for last month and post a summary here
```

### 2. Agent Reads the Thread

Opulent sees everything in the thread — all messages, shared files, links, and decisions. It understands what your team has been discussing without you having to re-explain.

### 3. Everyone Sees the Work

Progress updates appear in the thread. The team sees what the agent is doing and can redirect:

```
Team member: @opulent focus on the enterprise segment, not SMB
```

### 4. Collaborate on the Output

When results are ready, everyone in the thread can:
- Review and approve
- Request specific changes
- Ask the agent to go deeper on a section
- Refine iteratively until it's right

---

## Real-World Use Cases

### Turn Discussions into Deliverables

```
Thread: 45 minutes of product strategy discussion + uploaded roadmap doc

@opulent Turn this discussion and the attached doc into a 10-slide strategy
deck for the leadership meeting on Friday. Executive theme.
```

Agent reads the entire thread and the document, produces a presentation. Team reviews and refines in the same thread.

---

### Evaluate Proposals Together

```
Thread: Vendor pitch deck attached

@opulent Analyze this pitch deck. What are the strengths, weaknesses,
and the 5 most important questions we should ask them?
```

Team makes the decision collaboratively, with structured analysis from the agent.

---

### Live Data in Conversations

```
Thread: Monday revenue standup

@opulent Pull last week's Stripe MRR, new signups, and churn.
Post a 3-bullet summary here.
```

Live data surfaces in the conversation where the team is already meeting.

---

### Meeting Prep

```
Thread: Prep for 2pm call with Acme Corp

@opulent Research Acme Corp — recent news, key stakeholders, what they're likely
trying to solve. Post a pre-meeting brief here.
```

---

### Schedule and Calendar Actions

```
@opulent Book a 1-hour kickoff call with @sarah and @mike next Tuesday
afternoon. Use Google Calendar. Send invites to both.
```

---

## Collaboration Model

### Thread-Based Context

When you tag `@opulent`:
- The agent reads the **entire thread history** — not just your message
- All thread participants can interact with the agent
- All outputs are visible to everyone in the thread

### Access Control

New participants joining a thread after the agent is already active request access from the thread owner. This keeps sensitive tasks controlled.

---

## Setting Up

1. Go to **Settings → Connectors → Slack → Connect**
2. Authorize Opulent to access your Slack workspace
3. Opulent appears as a bot in your workspace
4. Tag `@opulent` in any channel or thread to start

---

## Tips

**Build context in the thread first, then tag the agent.** The more your team has discussed, the better the agent understands what you need.
- ✅ Long thread with clear discussion → `@opulent create a brief from this`
- ❌ Empty thread → `@opulent make a presentation`

**Be specific about the deliverable:**
- ✅ `@opulent Create a 6-slide summary deck. Focus on competitive positioning. Executive theme.`
- ❌ `@opulent make something about this`

**Iterate in the same thread:** Don't start a new thread for refinements — the agent remembers the full thread context.

**Use Slack as your daily briefing channel:** Set up a `#morning-brief` channel with a scheduled Opulent workflow that posts daily summaries.

---

## Common Questions

**Can @opulent access files shared in Slack?**
Yes. Files shared in the thread (PDFs, images, spreadsheets) are available for the agent to analyze.

**Can it post to a specific Slack channel on a schedule?**
Yes. Use Scheduled Tasks to run a workflow that posts results to any channel at any time. See [Scheduled Tasks](../features/scheduled-tasks.md).

**Can different team members direct the agent simultaneously?**
Yes. All thread participants can send messages. The agent processes them in order.

**Can the agent post proactive alerts to Slack?**
Yes. Configure workflows that trigger on connector events (new Stripe churn, deal closed, GitHub PR merged) and post a summary to a Slack channel.

**Does the agent post in real time or all at once?**
Results stream into the thread in real time, similar to how a team member would type a long message.

---

## Webhooks & Workflow Automation

**URL:** https://opulent-docs.vercel.app/docs/integrations/webhooks-zapier
**Description:** Webhooks & Workflow Automation - Opulent documentation

# Webhooks & Workflow Automation

> Connect Opulent to 8,000+ apps with no-code triggers — or fire tasks from any system via webhook

## What it is

Opulent can be triggered from any external system. When something happens in one of your tools — a new lead in your CRM, a form submission, a calendar event, a new Stripe payment — Opulent can automatically execute a task in response.

Two ways to set this up:

- **Webhooks** — Send an HTTP POST to your Opulent webhook URL from any system
- **Zapier** — Use visual no-code workflows connecting 8,000+ apps to Opulent without writing code

---

## Why This Matters

Most automation tools move data. They can't think, research, or create.

Combining external triggers with Opulent gives you **intelligent automation**:

| Traditional Automation | Opulent + Triggers |
|---|---|
| `"When X happens, copy data to Y"` | `"When X happens, have Opulent research, analyze, create, and deliver results to Y"` |
| New lead → add to spreadsheet | New lead → research company → score → draft personalized email → add to CRM |
| New ticket → assign to queue | New ticket → analyze issue → suggest resolution → draft response for agent review |
| New order → send confirmation | New order → create personalized follow-up → recommend complementary products |

---

## Webhooks

### Your Opulent Webhook URL

Go to **Settings → Integrations → Webhooks** to get your webhook endpoint:

```
POST https://artful-fly-108.convex.site/webhook/tasks
Authorization: Bearer YOUR_API_KEY
```

### Payload Format

```json
{
  "task": "Research {{company_name}} and create a pre-meeting brief. Include: employee count, recent funding, key stakeholders, and likely pain points.",
  "variables": {
    "company_name": "Acme Corp"
  },
  "output": {
    "slack_channel": "#sales-prep",
    "email": "team@company.com"
  }
}
```

### Example: CRM New Lead → Research

When a new lead is added to Salesforce, your CRM fires a webhook to Opulent:

```json
{
  "task": "Research this company and score the lead 1-10 based on our ICP criteria (B2B SaaS, 50-500 employees, US). Post score and brief to #new-leads in Slack.",
  "variables": {
    "company": "Acme Corp",
    "contact": "John Smith, VP Sales",
    "email": "john@acmecorp.com"
  }
}
```

---

## Zapier Integration

Zapier lets you connect Opulent to 8,000+ apps with a visual, no-code interface. If a tool you use supports Zapier, you can trigger Opulent tasks from it without any code.

### Setting Up a Zap

1. Go to [zapier.com](https://zapier.com) and create an account
2. Create a New Zap
3. **Choose a Trigger** — the app and event that starts the workflow
4. **Add Opulent as the Action** — search "Opulent" and select "Create Task"
5. Connect your Opulent account
6. Write the task prompt (can include dynamic data from the trigger)
7. Test and activate

---

## Popular Workflow Examples

### 1. Meeting Preparation

```
Trigger: New Calendly meeting scheduled
Prompt: "Research {{attendee_company}}. Find: employee count, recent news,
        {{attendee_name}}'s role and background, and likely priorities.
        Create a pre-meeting brief and post to #sales-prep in Slack."

Result: You walk into every meeting fully prepared — automatically.
```

---

### 2. Lead Qualification

```
Trigger: New lead in HubSpot or Salesforce
Prompt: "Research {{company_name}}. Score 1-10 based on: company size,
        industry fit, tech stack indicators, and recent funding signals.
        Update the CRM record with score and research notes."

Result: Every new lead is enriched and scored before a rep touches it.
```

---

### 3. Form Submission Analysis

```
Trigger: New Google Forms response
Prompt: "Analyze this feature request from {{submitter_name}}:
        {{response_text}}
        Categorize it, estimate impact, and add to our Notion product backlog
        with a priority recommendation."

Result: Every request is triaged before the PM sees it.
```

---

### 4. Support Ticket Triage

```
Trigger: New ticket in Zendesk or Intercom
Prompt: "Analyze this support ticket: {{ticket_text}}
        Categorize the issue type, check our knowledge base for existing solutions,
        and draft a suggested response. Post to #support-queue in Slack."

Result: First-response drafts are ready before a support agent picks up the ticket.
```

---

### 5. Meeting Transcript Processing

```
Trigger: New Zoom/Fireflies transcript available
Prompt: "Summarize this meeting transcript: {{transcript_url}}
        Extract: key decisions, action items with owners, and open questions.
        Post to the project Notion page and send action items to each owner via email."

Result: Meeting notes and action items distributed automatically after every call.
```

---

### 6. E-commerce Post-Purchase

```
Trigger: New order completed in Shopify
Prompt: "Create a personalized follow-up email for {{customer_name}} who just
        purchased {{product_name}}. Include: 3 usage tips for their specific product,
        a relevant complementary product recommendation, and a request for review."

Result: Intelligent, personalized post-purchase engagement at scale.
```

---

### 7. Scheduled Intelligence Reports

```
Trigger: Schedule by Zapier — Every Monday at 9 AM
Prompt: "Research our 5 main competitors for updates from the past 7 days:
        new product launches, pricing changes, job postings, and press mentions.
        Create a weekly competitive intelligence report and post to #competitive-intel."

Result: The team starts every Monday with a fresh competitive update.
```

---

## Available Actions

| Action | Description |
|---|---|
| **Create Task** | Trigger a new Opulent task with a custom prompt |
| **Get Task Status** | Check if a task is complete and retrieve its output |
| **Update Task** | Modify task properties |
| **Delete Task** | Remove a task |

---

## Tips for Effective Triggers

**Use dynamic data from the trigger:**
- ✅ `"Research {{company_name}} from the meeting. Find {{attendee_name}}'s background."`
- Dynamic variables make every triggered task personalized and relevant

**Be specific in prompts:**
- ✅ `"Create a brief with: company size, funding history, key decision makers, and 3 conversation starters"`
- ❌ `"Research this company"` — too vague for consistent results

**Add filters for precision:**
```
Trigger: New email in Gmail
Filter: Subject contains "partnership inquiry" AND sender not in team domain
Action: Opulent researches sender's company
```
This prevents unnecessary task creation and focuses on high-value triggers.

**Chain Zapier actions after Opulent:**
1. Trigger: New form submission
2. Action 1: Opulent creates analysis
3. Action 2: Add Opulent result to Google Sheet
4. Action 3: Notify Slack

---

## Common Questions

**Does webhook triggering cost extra?**
Webhook and Zapier-triggered tasks consume the same credits as manually triggered tasks. No additional per-trigger fee.

**Can I use webhooks without Zapier?**
Yes. Any system that can send an HTTP POST can trigger Opulent directly — no Zapier required.

**How do I get results back into the triggering system?**
Specify an output destination in the task prompt (`"post to Slack"`, `"update Salesforce record"`, `"email to..."`) and connect the relevant connectors.

**Can Opulent trigger webhooks outbound (not just receive them)?**
Yes. As part of a task, the agent can POST to external webhook URLs as a delivery mechanism.

**What's the latency on webhook-triggered tasks?**
Tasks begin processing within seconds of receiving the webhook. Completion time depends on task complexity.

---

## Links

- [GitHub](https://github.com/OpulentiaAI)
- [Discord](https://discord.gg/opulent)
- [Support](mailto:support@opulentia.ai)