Pine Voice lets your agent dial real phone numbers, talk to humans, and return transcripts. Pine Assistant goes further — negotiating bills, cancelling subscriptions, and resolving disputes end-to-end. Drop in via OpenClaw, MCP, or SDK.
Pine AI is an AI assistant that makes real phone calls on your behalf — negotiating bills, cancelling subscriptions, filing complaints, booking appointments, and more. We bring that same voice agent to OpenClaw, Cursor, and any developer tool you use.
Pine gives your AI agent real-world capabilities — whether it's a single phone call or an end-to-end task with research, forms, and follow-ups.
You provide a phone number, objective, and instructions. Pine's voice agent makes the call, handles the conversation, and returns a transcript. A single synchronous operation.
Tell Pine what you need. It researches your account, asks follow-up questions, plans a strategy, makes calls, sends emails, handles identity verification, and follows up. An asynchronous, multi-step workflow.
Other AI agents stop at the terminal. Pine picks up the phone, waits on hold for an hour, out-negotiates the retention agent, and resolves your problem end to end — while you keep coding.
Natural, conversational voice that holds its own with real customer service reps. Not a script reader — Pine adapts, responds to follow-ups, and stays on point for up to an hour.
Hour-long hold times, IVR phone trees, transfers between departments — Pine handles all of it. You get a notification when it’s done.
No Mechanical Turk behind the curtain. Pine is fully autonomous from dial to hang-up — purpose-trained on customer service scenarios across 50,000+ users.
You provide a number, objective, and context. Pine dials, handles the conversation, and returns a transcript.
You say “negotiate my Comcast bill.” Pine researches, strategizes, calls, negotiates, and reports back.
Two OpenClaw plugins for deep runtime integration, plus two ClawHub skills for lightweight agent access.
Prerequisite: Pine AI Pro account
You need a Pine AI account with an active Pro subscription. The Pro plan includes monthly credits for voice calls and tasks.
Don’t have an account yet? Sign up at 19pine.ai and upgrade to Pro.
Adds voice call tools to your agent. Your agent provides a phone number and instructions; Pine's voice agent makes the call and returns a transcript.
openclaw plugins install openclaw-pine-voice
openclaw gateway restartAsk your OpenClaw agent to set up authentication:
"Set up Pine Voice authentication"The agent walks you through email verification, saves credentials, and automatically adds the voice tools to your config. Then restart the gateway:
openclaw gateway restartSkipped auth? No problem — the plugin still loads without a token. The first time your agent tries to make a call, it will detect the missing token and walk you through the email verification flow automatically.
Pine Voice requires models with thinking/reasoning capabilities. Models without thinking may be too slow or cause context issues.
Recommended: Claude Sonnet / Opus 4.5+, GPT-5.2+, Gemini 3 Pro
Not recommended: Gemini 3 Flash, or any model without thinking capabilities
Unrecognized key errorIf you see Unrecognized key: "allow" after editing your config manually, you likely placed "allow" inside the plugin entry instead of at the root level. Here’s the difference:
{
"plugins": {
"entries": {
"openclaw-pine-voice": {
"allow": ["..."]
}
}
}
}{
"tools": {
"allow": [
"pine_voice_call_and_wait",
"pine_voice_call",
"pine_voice_call_status"
]
}
}Run openclaw doctor --fix to auto-repair your config. Note: if you use the auth flow (recommended), tools.allow is configured automatically — no manual editing needed.
# Step 1: Request a verification code (sent to your email)
openclaw pine-voice auth setup --email [email protected]
# Step 2: Check your email, then verify
openclaw pine-voice auth verify --email [email protected] --request-token <TOKEN> --code 1234Then restart the gateway: openclaw gateway restart
English only. The voice agent can only speak English. Calls can be placed to the US, Canada, Puerto Rico (+1), UK (+44), Australia (+61), New Zealand (+64), Singapore (+65), Ireland (+353), and Hong Kong (+852).
| Built-in voice_call | Pine pine_voice_call | |
|---|---|---|
| Voice quality | Depends on your TTS setup | Human-like, natural tone |
| Complex calls | Basic scripted flows | Purpose-trained for hour-long negotiations |
| Webhook URL? | Yes (ngrok/Tailscale) | No |
| Twilio/Telnyx? | Yes | No |
| IVR navigation | None | Automatic |
| Best for | Simple voice bots | Negotiations, interviews, customer service |
Give your agent a real phone — it dials, waits on hold, negotiates your bills, and returns a full transcript. Bundled Node.js scripts, zero config, no plugin needed.
Higher LLM token cost. The skill polls for call results via curl, consuming LLM tokens while waiting. The openclaw-pine-voice plugin’s pine_voice_call_and_wait blocks at the runtime level with zero LLM cost during the wait. For frequent use, the plugin is more cost-efficient.
clawhub install pine-voiceJust ask your agent — it handles the entire auth flow conversationally:
"Set up Pine Voice authentication"The agent will ask for your Pine AI email, send a verification code, and save credentials to ~/.pine-voice/credentials.json. No env vars, no manual token copying.
Once authenticated, just ask:
"Call +14155559876 and make a reservation for 4 at 7pm tonight"Registers Pine Assistant as a channel in OpenClaw. The plugin maintains a persistent Socket.IO connection to Pine, receives events (forms, questions, call updates, state changes), and routes them to the agent. The agent’s replies are automatically delivered to the user’s messaging channel (Telegram, WhatsApp, etc.) via channel tracking. Multi-step tasks with forms, follow-ups, and live call progress.
openclaw plugins install openclaw-pine
openclaw gateway restartAsk your OpenClaw agent to set up authentication:
"Set up Pine Assistant authentication"The agent will walk you through email verification, save credentials automatically, and enable the Pine Assistant channel. Then restart the gateway: openclaw gateway restart
Skipped auth? No problem — the plugin still loads without a token. The first time your agent tries to create a session, it will detect the missing credentials and walk you through the email verification flow.
# Step 1: Request a verification code (sent to your email)
openclaw pine auth setup --email [email protected]
# Step 2: Check your email, then verify
openclaw pine auth verify --email [email protected] --request-token <TOKEN> --code 1234Then restart the gateway: openclaw gateway restart
Handle customer service, bills, reservations, and more from your terminal. The skill uses the pine CLI under the hood — no plugin needed, works with any ClawHub-compatible agent.
No automatic follow-ups. The CLI skill cannot receive callbacks or push notifications from Pine. It cannot auto-receive updates, form requests, or three-party call alerts. You (or your agent) must proactively check progress by polling pine sessions get. Time-sensitive events like OTPs and call joins may be missed.
Need real-time events? Use the openclaw-pine plugin instead — it maintains a persistent Socket.IO connection, receives events instantly, and routes them to the agent automatically.
clawhub install pine-assistantThis auto-installs the pineai-cli package (provides the pine command) as a dependency.
Just ask your agent:
"Set up Pine Assistant authentication"The agent runs pine auth request + pine auth verify non-interactively, saving credentials to ~/.pine/config.json.
Once authenticated, just ask:
"Negotiate my Comcast bill down. I'm paying $120/mo and want $80/mo."Use Pine directly from Cursor, Claude Code, Claude Desktop, OpenAI Codex, or any MCP-compatible client. No plugins, no OpenClaw — just add the server config.
Two MCP servers for different workflows
Pine Voice MCP is a remote server — your client connects over HTTP and gets transcripts in real time. Pine Assistant MCP runs locally via pine-mcp-server — the agent creates sessions, sends messages, and polls for updates using a “load conversation” model.
A hosted MCP server for direct phone calls. Your client connects over HTTP — provide a phone number and instructions, get a transcript back. No local install required.
You’ll need your Access Token and User ID. Get your credentials ↑
Create or edit .cursor/mcp.json in your project root:
{
"mcpServers": {
"pine-voice": {
"type": "streamablehttp",
"url": "https://agent3-api-gateway-staging.19pine.ai/mcp",
"headers": {
"Authorization": "Bearer YOUR_TOKEN_HERE",
"X-Pine-User-Id": "YOUR_USER_ID"
}
}
}
}Add via CLI:
claude mcp add pine-voice \
--transport http \
--url https://agent3-api-gateway-staging.19pine.ai/mcp \
--header "Authorization: Bearer YOUR_TOKEN_HERE" \
--header "X-Pine-User-Id: YOUR_USER_ID"Or create a .mcp.json file in your project root:
{
"mcpServers": {
"pine-voice": {
"type": "http",
"url": "https://agent3-api-gateway-staging.19pine.ai/mcp",
"headers": {
"Authorization": "Bearer YOUR_TOKEN_HERE",
"X-Pine-User-Id": "YOUR_USER_ID"
}
}
}
}Settings → Developer → Edit Config, then add:
{
"mcpServers": {
"pine-voice": {
"type": "streamablehttp",
"url": "https://agent3-api-gateway-staging.19pine.ai/mcp",
"headers": {
"Authorization": "Bearer YOUR_TOKEN_HERE",
"X-Pine-User-Id": "YOUR_USER_ID"
}
}
}
}Add to ~/.codex/config.toml (or project-scoped .codex/config.toml):
# Set env vars: PINE_ACCESS_TOKEN, PINE_USER_ID
[mcp_servers.pine-voice]
url = "https://agent3-api-gateway-staging.19pine.ai/mcp"
bearer_token_env_var = "PINE_ACCESS_TOKEN"
[mcp_servers.pine-voice.env_http_headers]
X-Pine-User-Id = "PINE_USER_ID"Or add via CLI:
codex mcp add pine-voice \
--url https://agent3-api-gateway-staging.19pine.ai/mcpThen edit ~/.codex/config.toml to add the bearer_token_env_var and env_http_headers fields.
Start with a test call to yourself to verify everything works:
"Call my phone at +1XXXXXXXXXX. Tell me that Pine Voice is set up and working, and ask if I have any questions before hanging up."Replace with your real number. You'll receive a real call from Pine's voice agent.
Gather all info first. The voice agent cannot ask you for more info during the call. Include all details the callee may need — authentication, verification, payment details, negotiation targets, and constraints.
Agent calls pine_voice_call
Pine dials, navigates IVR, handles conversation
SSE keeps session open until call completes
Full transcript, outcome, and billing info
A local MCP server that exposes the full Pine Assistant workflow — negotiate bills, cancel subscriptions, resolve disputes, and more. The agent creates sessions, sends messages, handles forms, and polls for updates using a “load conversation” model.
Built on the pine-assistant Python SDK. Published as pine-mcp-server on PyPI.
pip install pine-mcp-serverOr run directly with uvx (no install needed): uvx pine-mcp-server
You’ll need your Access Token and User ID. Get your credentials ↑
Add to .cursor/mcp.json in your project root:
{
"mcpServers": {
"pine-assistant": {
"command": "uvx",
"args": ["pine-mcp-server"],
"env": {
"PINE_ACCESS_TOKEN": "YOUR_TOKEN_HERE",
"PINE_USER_ID": "YOUR_USER_ID"
}
}
}
}If you used pip install, replace "command": "uvx" with "command": "pine-mcp-server" and remove the "args" field.
Add via CLI:
claude mcp add pine-assistant \
--command uvx \
--args pine-mcp-server \
--env PINE_ACCESS_TOKEN=YOUR_TOKEN_HERE \
--env PINE_USER_ID=YOUR_USER_IDSettings → Developer → Edit Config, then add:
{
"mcpServers": {
"pine-assistant": {
"command": "uvx",
"args": ["pine-mcp-server"],
"env": {
"PINE_ACCESS_TOKEN": "YOUR_TOKEN_HERE",
"PINE_USER_ID": "YOUR_USER_ID"
}
}
}
}Add to ~/.codex/config.toml (or project-scoped .codex/config.toml):
[mcp_servers.pine-assistant]
command = "uvx"
args = ["pine-mcp-server"]
[mcp_servers.pine-assistant.env]
PINE_ACCESS_TOKEN = "YOUR_TOKEN_HERE"
PINE_USER_ID = "YOUR_USER_ID"Or add via CLI:
codex mcp add pine-assistant \
--command uvx \
--args pine-mcp-serverThen edit ~/.codex/config.toml to add the env section with your credentials. If you used pip install, replace "uvx" with "pine-mcp-server" and remove the args field.
Credentials optional at startup. If you skip the environment variables, the server still starts. Your agent can authenticate at runtime using the built-in pine_auth_request_code and pine_auth_verify_code tools.
The server follows a “load conversation” model — like refreshing a browser page:
pine_session_create
pine_send_message
pine_get_history
pine_task_start
pine_get_history
No real-time streaming. The agent periodically loads conversation history to see updates.
Ask your agent to handle a task:
"Use Pine AI to negotiate my Comcast internet bill. My account number is 12345."The agent will create a session, send your request, and check back for updates.
| Category | Tool | Description |
|---|---|---|
| Auth | pine_auth_request_code | Request a verification code via email |
| pine_auth_verify_code | Verify the code and obtain credentials | |
| Sessions | pine_session_create | Create a new Pine session |
| pine_session_list | List sessions with optional filters | |
| pine_session_get | Get details about a session | |
| pine_session_delete | Delete a session | |
| pine_session_url | Get the web URL to view a session | |
| Conversation | pine_get_history | Load conversation history (the core “refresh” tool) |
| pine_send_message | Send a text message to Pine | |
| pine_send_form_response | Submit a form that Pine sent | |
| pine_send_auth_confirmation | Submit an OTP / verification code | |
| pine_send_location_response | Submit location coordinates | |
| pine_send_location_selection | Submit a location selection | |
| Tasks | pine_task_start | Start task execution |
| pine_task_stop | Stop a running task | |
| Attachments | pine_upload_attachment | Upload a local file (bill, screenshot, etc.) |
| pine_delete_attachment | Delete an uploaded attachment |
Add Pine to any application. Each mode uses a separate library.
pine-voice Python JSfrom pine_voice import PineVoice
client = PineVoice()
result = client.calls.create_and_wait(
to="+14155551234",
name="Dr. Smith",
objective="Schedule a cleaning",
)
print(result.summary)import { PineVoice } from "pine-voice";
const client = new PineVoice();
const result = await client.calls.createAndWait({
to: "+14155551234",
name: "Dr. Smith",
objective: "Schedule a cleaning",
});
console.log(result.summary);Both SDKs include built-in authentication. Run once to get your credentials:
from pine_voice import PineVoice
email = input("Pine AI account email: ")
token = PineVoice.auth.request_code(email)
print("Check your email for a verification code.")
code = input("Verification code: ")
creds = PineVoice.auth.verify_code(email, token, code)
print(f"PINE_ACCESS_TOKEN={creds.access_token}")
print(f"PINE_USER_ID={creds.user_id}")import { PineVoice } from "pine-voice";
import { createInterface } from "readline/promises";
const rl = createInterface({ input: process.stdin, output: process.stdout });
const email = await rl.question("Pine AI account email: ");
const { requestToken } = await PineVoice.auth.requestCode(email);
console.log("Check your email for a verification code.");
const code = await rl.question("Verification code: ");
const creds = await PineVoice.auth.verifyCode(email, requestToken, code);
rl.close();
console.log(`PINE_ACCESS_TOKEN=${creds.accessToken}`);
console.log(`PINE_USER_ID=${creds.userId}`);Save as environment variables, then create the client with no arguments: PineVoice() / new PineVoice()
pine-assistant Python JSfrom pine_assistant import AsyncPineAI
client = AsyncPineAI(access_token="...", user_id="...")
await client.connect()
session = await client.sessions.create()
async for event in client.chat(session["id"], "Negotiate my bill"):
print(event)import { PineAI } from "pine-assistant";
const client = new PineAI({ accessToken: "...", userId: "..." });
await client.connect();
const session = await client.sessions.create();
for await (const ev of client.chat(session.id, "Negotiate my bill"))
console.log(ev);pineai-cli GitHub PyPIOne pine command for both Voice calls and Assistant tasks. Python 3.10+.
pip install pineai-cli# Authenticate
pine auth login # Interactive email verification
pine auth request --email [email protected] # Non-interactive (for agents)
# Assistant sessions
pine sessions list --json # List all sessions
pine sessions create --json # Create a new session
pine sessions get <session-id> --json # Get session details & history
pine send "Negotiate my bill" -s <id> --json # Send message to session
pine send "Cancel Netflix" --new --json # Create session & send
pine send "checking in" -s <id> --no-wait # Fire-and-forget
pine chat # Interactive REPL
pine task start <session-id> # Start task execution
# Voice calls
pine voice call --to "+14155551234" --name "Dr. Smith" \
--context "Dentist office" --objective "Schedule a cleaning"
pine voice status <call-id>Pine Voice calls use your Pine AI credit balance. Pine AI Pro subscription required.
Every call is reviewed for safety before dialing. Calls that violate these policies are automatically rejected.
Handling sensitive tasks like bills, taxes, and healthcare requires absolute trust. Pine is built with bank-level security, transparent privacy controls, and a simple promise: we never sell your data.
All data is encrypted in transit and at rest using industry-standard protocols (128-bit or higher). Sensitive data is processed ephemerally in a cryptographic vault and erased when the job is done — it’s never stored.
Independent security experts regularly test Pine’s systems and identify potential vulnerabilities. Practices are aligned with leading frameworks including SOC 2, GDPR, and CCPA.
Pine is fully autonomous — no human operators listen to calls or view your data. A dedicated security team continuously monitors systems and will notify you immediately if unusual activity is detected.