Perplexity Launches Always-On Teammates for Multi-Agent Work

Summary:Perplexity has introduced Teammates, an always-on, work-focused agent system that lets users assign different roles to multiple agents within a shared workspace. Built on top of Perplexity Computer, which can deploy agents on a device to execute tasks, Teammates is designed to support parallel, ongoing, large-scale work while reusing existing projects, skills, and memory from the user's Perplexity tools. The release puts Perplexity in direct competition with products such as OpenAI's Dots and A

---

From One-Shot Conversations to Persistent Workspaces

Perplexity has launched Teammates, shifting work-focused AI agents from single-turn conversations and short-lived tasks toward persistent workspaces. Users can assign different roles to multiple Teammates within the same workspace, allowing them to work in parallel on research, organization, writing, and other ongoing assignments while sharing project, skill, and memory context.

Teammates builds on Perplexity Computer, which can deploy agents on a device to execute tasks. The new layer adds multi-role collaboration and parallel execution for larger, longer-running work.

Core Mechanism: Role-Based Orchestration

Based on the public description, Teammates is not a new foundation model. It reorganizes capabilities that already exist within Perplexity into a persistent multi-agent system.

Its basic execution loop can be modeled as follows:

1. The user defines tasks and role boundaries for a workspace.
2. The system assigns subtasks to one or more Teammates.
3. Each agent uses search, Computer, or other tools to complete its part of the work.
4. Project, skill, and memory context is reused across roles.
5. Agents progress in parallel, maintain shared state, and consolidate the results.

This differs from simply asking one model to make more tool calls. Parallel agents can increase workload throughput by overlapping waits for CPUs, browsers, and external services. Parallelism does not necessarily reduce the latency of a single critical path, however. Duplicate research, concurrent writes to the same state, and cross-agent validation can increase both latency and token consumption.

Shared Memory Is the Core Value—and the Core Risk

Teammates can pull projects, skills, and memory from users' existing Perplexity tools. That means it does not need to reconstruct the entire background for every new session. For research, report iteration, and recurring operations, state reuse can reduce repeated prompting and limit inconsistent interpretation across agents.

Shared memory also expands the attack surface. If multiple always-on agents can access browsers, files, code repositories, or enterprise systems, the platform must define:

• Minimum permissions and writable directories for every role;
• Memory provenance, expiration, and sensitive-data redaction;
• Conflict detection and transactions for concurrent modifications;
• Retry, idempotency, and rollback behavior after tool failures;
• Whether user approval occurs before an action or before final commit.

Prompt injection deserves particular attention. Malicious instructions embedded in a webpage or file could propagate across agents and influence other roles through shared memory. External content should therefore be treated as untrusted data rather than system instructions, with isolated execution contexts for each agent.

Positioning Against Computer, Dots, and Claude Duet

Teammates builds on Perplexity Computer. Computer is closer to the device execution layer, letting agents operate local applications; Teammates adds workspace, role, and collaboration abstractions above it. This separation allows the device layer to be reused, but also creates dependency-management challenges: once one agent changes browser state, other agents need a reliable way to verify that the state remains valid.

The product targets the same broad market as OpenAI's Dots and Anthropic's Claude Duet: multiple agents working together on sustained knowledge tasks rather than operating only through a chat interface. The real point of differentiation will not be the feature list. It will be task-completion rate, waiting time, frequency of human intervention, and reliability when operating real software.

Throughput, Latency, and Cost Trade-offs

Multi-agent parallelism usually improves workspace throughput by allowing independent tasks to overlap. Its resource cost, however, can exceed that of a single-agent design. Each role may maintain separate context, tool histories, and reasoning budgets, so model calls often scale with the number of roles.

If there are (N) concurrent roles and each role makes an average of (M) model calls, the approximate call volume scales with (NM). Shared context and prompt caching can reduce duplicate prefill costs, but KV Cache, tool state, and memory indexes still consume memory. Production systems should allocate roles dynamically around task independence and phase boundaries rather than starting a permanent process for every subtask.

Useful evaluations include:

• Task-completion and human-rework rates;
• p50 and p95 end-to-end latency;
• Model-token and tool-call cost per successful task;
• Resource isolation and tail latency under concurrent workspaces;
• Recovery after browser or desktop-action failures;
• Memory contamination, unauthorized access, and incorrect result propagation.

Evaluation Must Go Beyond Product Demonstrations

The available report does not disclose Teammates' underlying models, orchestration strategy, Computer action-success rate, sandbox implementation, benchmark suite, latency, or pricing. Claims about continuous and large-scale collaboration need measurable definitions, such as information coverage and citation accuracy over multi-hour research tasks, cross-agent state consistency, and correct suspension when an operation requires permission.

Without public baselines, teams can construct their own task sets with both independently parallel subtasks and inherently sequential dependencies. They should compare a single agent, sequential multi-agent execution, and Teammates, then inject prompt injection, stale memory, tool timeouts, and concurrent writes to test whether failures remain recoverable.

Deployment Guidance

For individuals, Teammates is best introduced through bounded and verifiable workloads such as competitor-research summaries, document-difference checks, and recurring reports. High-impact actions—payments, repository deletion, and production changes—should not be delegated without review.

For enterprise teams, governance should precede broad deployment. Organizations need a role-to-permission matrix, human approval for writes and external publication, tool-call logs with state versions, tenant isolation for shared memory, provenance and expiration policies, and cost tracking based on completed business outcomes rather than the number of agents.

Teammates shows Perplexity expanding from a search-and-answer product into a device-execution and multi-agent collaboration platform. It directly overlaps with OpenAI's and Anthropic's work-agent efforts, but current public information does not establish a reliability or cost advantage. The deciding factor will not be agent count; it will be whether the system preserves correct state over long-running work, keeps permissions controllable, recovers from failures, and converts parallel execution into dependable business output.

---

Source: The Verge AI (2026-11-05)

— END —

Tags: #Perplexity Follow #Multi-Agent Systems Follow #AI Agents Follow #Workflow Automation Follow #On-Device Execution Follow