canonical: https://jentic.com/apis/pocketfm.org/pocketfm

# Pocketfm UGC AI Copilot API

The UGC AI Copilot API runs AI reasoning tasks in Ask, Plan, Review, and Research modes for user-generated content workflows. It uses an async polling model: a request triggers a task, and the caller polls the task status to retrieve the generated content once it completes. Tasks are tracked through a lifecycle from pending to processing, completed, or failed within a conversation thread.

## For AI agents

Trigger AI copilot tasks in Ask, Plan, Review, or Research mode, then poll task status in a thread to retrieve generated content. Uses an async request_id-based task model.

## Scope

Does not handle audio streaming, payments, or user management. Use for AI copilot task generation only.

## Capabilities

- Trigger AI tasks in Ask, Plan, Review, or Research modes
- Poll task status and retrieve the generated content
- List the tasks running in a conversation thread
- Track a task through its pending, processing, and completed lifecycle

## Use cases

### AI Copilot Integration

An AI agent connected to the UGC AI Copilot through Jentic can delegate a reasoning task by triggering an Ask or Research run, then poll the task status until the content is ready. The async model means the agent fires the request and checks back, rather than holding a long synchronous call open.

Example prompt: Trigger a Research task in a thread, then poll task status until it completes and read the content

### Async Task Orchestration

Orchestrate long-running AI work by triggering tasks and polling for completion with request-id tracking. The copilot models each task's lifecycle as pending, processing, completed, or failed, so an agent can route on status rather than block.

Example prompt: List the tasks in a thread and poll the status of the one still processing

### Content Review Workflow

Run Review-mode tasks to produce structured review output over user-generated content. The copilot returns review results an agent can parse and act on, keeping the review consistent across submissions.

Example prompt: Trigger a Review task on a piece of content and retrieve the structured review output

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/v1/agent/universal-ai-chat` | Trigger an AI task in Ask, Plan, Review, or Research mode |
| GET | `/api/v1/chat/threads/{thread_id}/tasks/list` | List tasks in a thread |
| GET | `/api/v1/chat/threads/{thread_id}/tasks/status` | Get task status with content |

## Key resources

- **AI Tasks** — Ask, Plan, Review, and Research tasks triggered through the copilot
- **Threads** — Conversation threads that group tasks
- **Task Status** — Lifecycle status and generated content for a task

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 38 / 100
- **Maturity:** Non-Ready
- **Dimensions:**
  - Foundational Compliance: 93 / 100
  - Developer Experience & Jentic Compatibility: 59 / 100
  - AI-Readiness & Agent Experience: 17 / 100
  - Agent Usability: 94 / 100
  - Security: 75 / 100
  - AI Discoverability: 33 / 100
- **View full report:** https://jentic.com/apis/pocketfm.org/pocketfm/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the UGC AI Copilot by hand means handling its bearer JWT auth and its async trigger-then-poll task model yourself. Through Jentic you install once, import it from the API Directory, store the token once, and your agent calls it.
- **Permission scoping:** The copilot carries its mode and prompt in the request body, so a rule bounds which operations your agent may call rather than which thread. A rule can allow triggering tasks and reading status while keeping the surface to exactly those operations.
- **Credential handling:** Your UGC AI Copilot token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'ask the copilot a question', and Jentic returns the matching UGC AI Copilot operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **OpenAI** — General chat and reasoning models, where the UGC AI Copilot wraps modes behind an async task API.
- **Anthropic Messages** — Claude chat completions, an alternative reasoning backend to the copilot's task modes.
- **Cohere** — Embeddings and rerank for retrieval, complementing the copilot's reasoning tasks.

## FAQ

### Is there a PocketFM AI Copilot MCP server?

You don't need an MCP server to give your agent the UGC AI Copilot API. Jentic connects it directly from the API Directory: import it, store your token once, and your agent can trigger tasks and poll their status. Operations are discovered on demand, so your agent's context stays lean.

### Can I limit what my agent is allowed to do with the UGC AI Copilot API?

Yes. The copilot carries its mode and prompt in the request body, so a rule bounds which operations your agent may call. Write a rule that allows triggering tasks and reading status and nothing more, and every call Jentic makes is logged.

### What authentication does the UGC AI Copilot API use?

The UGC AI Copilot API authenticates with a bearer token in the Authorization header, formatted as a JWT per its OpenAPI spec. With Jentic, the token is stored encrypted by your own Jentic One instance and injected at call time, so it never reaches the agent.

### How does the async task model work in the UGC AI Copilot API?

A request triggers a task and returns a request id, then your agent polls the task status endpoint in the thread until the task moves from pending or processing to completed. The status response carries the generated content once the task is done.

### What are the rate limits for the UGC AI Copilot API?

The OpenAPI spec does not specify rate limits. Check the PocketFM documentation at https://pocketfm.org for current limits before triggering tasks at high volume.

### How do I trigger an AI task with the UGC AI Copilot API through Jentic?

Import the UGC AI Copilot API from the Jentic API Directory, store your token once, and have your agent search by intent such as 'ask the copilot a question'. Jentic returns the trigger operation with its input schema, and your agent passes the mode and prompt. To run it on your own infrastructure, install Jentic One from its GitHub repo.