AgentPlat

Build applications where humans and AI agents get work done together.

AgentPlat gives your application the foundation to coordinate teams of agents, preserve shared work across sessions and interruptions, and keep people in control of critical decisions—all on your infrastructure.

Open-source TypeScript framework · Apache-2.0 · Developer preview
Component maturity · Integration responsibilities

Check preview versions npm view @agentplat/framework dist-tags
Fault-tolerant coordination Inspect recovery at documented process-failure boundaries.
Bounded autonomy Add Collective Runtime and Agent Mesh when your application needs them.
Verifiable operations Retain artifacts and decisions; explicitly wire checkpoints for protected effects.

New integration · source preview

Optional Jev assessments for AgentPlat

Developers who choose TypeSafe Jev can turn assessment output into typed signals for classifying or routing work. Your application still selects the data and rubric, and keeps control of policy, human approval and protected actions. The adapter is implemented in source, is not on npm yet, and has no live quality or cost comparison.

See what the integration is for → · Read the Jev assessor docs

For developers

What value does AgentPlat bring to developers?

Build applications where humans and agents work together, with persistent state, approvals and controlled execution on your own infrastructure. Reuse the work model around the model call.

  • Keep work beyond the chat

    Agent Rooms connect participants, messages, tasks and versioned artifacts, so you can reuse a collaboration model instead of designing one from scratch.

  • Make room for human decisions

    Model approvals, contributions and interventions as part of the work. A person can add context or request changes in a process that outlives a session.

  • Give each agent a clear next step

    Use task dependencies, capability-based assignment and typed handoffs to make who does what, and what happens next, explicit.

  • Build for interruptions

    Durable storage adapters, revision checks and leases support recovery and controlled retries. Preventing duplicate external effects still depends on your integrations.

  • Understand how work happened

    Inspect artifact versions, events and agent-definition references to reconstruct the work and give reviewers useful context.

  • Choose your infrastructure

    Public interfaces for models, storage, execution, tools and events let you replace infrastructure while keeping your application's work model.

Illustrative workflow

One proposal. Agents and people.

  1. Research. One agent gathers information; the drafting task depends on its findings.
  2. Draft and review. Another agent prepares the proposal. A person adds conditions or requests changes.
  3. Revise and approve. Keep artifact versions and approval history together as the work moves forward.

With durable adapters configured, work can persist across human waits and recoverable interruptions. You build the business logic, UI and integrations.

Open source · Apache-2.0

Why open source matters

Inspect the implementation, adapt behavior and build your own adapters. Self-host without private AgentPlat services, choose where data lives and keep the code available for maintenance.

Your team operates hosting, inference, identity, backups and connectors. Data handling depends on the providers and configuration you choose.

Developer preview. APIs may change. Review current status and integration details.

A strong fit for TypeScript teams building internal agent platforms, SaaS workspaces with approvals, or long-running collaborative automation. For a simple text-generation feature, start small with AgentPlat.ask.

AgentPlat on npm

Building blocks for your next AI application.

Bring AgentPlat into your own product with our family of open-source npm packages. Start with the pieces you need and explore more as your ideas grow.

Bring agents to life

A foundation for building and running AI agents as part of your application.

  • @agentplat/framework
  • @agentplat/runtime

Make room for collaboration

Give people and agents a shared place to work, keep context and move decisions forward.

  • @agentplat/rooms
  • @agentplat/rooms-api

Connect teams of agents

Help agents coordinate around shared goals and work together across your application.

  • @agentplat/collective-runtime
  • @agentplat/mesh

Beyond single-agent automation

From isolated agents to resilient collective operations.

Adding more agents is not enough. Critical work needs coordination that contains failures, preserves authority and produces evidence that teams can inspect after every decision.

Questions to resolve

design review
  • -How will you bound coordination and shared context?
  • -Which process and network failure boundaries must recover?
  • -Where are identity, work ownership and action authority verified?
  • -Which artifacts and decisions must remain inspectable?

AgentPlat collective operations

resilient by design
  • +Coordinates through bounded local cells that can scale across larger populations.
  • +Recovers assignments, membership and communication after expected failures.
  • +Provides protected-action controls for explicit host and provider integration.
  • +Records decisions, recovery and outcomes as inspectable evidence.

Human-agent collaboration

Give every mission a governed place to work.

Agent Rooms bring people, agents, context, tasks, artifacts, approvals and evidence together in one tenant-scoped operational workspace.

The design origin

Agent Rooms originated in the paper Agent Rooms: A Conceptual Framework for Persistent Human-Governed Multi-Agent Collaboration by Douglas Rodriguez. The paper defines the persistent, governed collaboration container behind this product direction.

Read the paper and cite the framework → Explore the research →

Disconnected collaboration

context loss
  • -Chats, tasks and approvals scattered across tools.
  • -Human review disconnected from agent execution and evidence.
  • -Context and provenance disappear between handoffs.

AgentPlat Rooms

governed workspace
  • +Messages, artifacts, tasks and memory provenance stay together.
  • +People can review work and approve protected transitions.
  • +Room state connects to collective coordination and recovery.

New research · Preprint v1.0

Governed Agent Morphogenesis: Runtime Organizational Reconfiguration with Bounded Authority and Causal Continuity.

The paper examines how multi-agent organizations can change at runtime while preserving bounded authority and causal continuity across independently owned subsystems. Its evidence compares governed reconfiguration with fixed, minimally adaptive and durable-workflow baselines, and documents how losing proposals with partial effects are reconciled.

Douglas Rodríguez · Preprint v1.0 · 22 September 2026

Agent Morphogenesis

Adapt the team as the mission changes.

AgentPlat Agent Morphogenesis coordinates governed changes to agents, roles, teams and strategies. Recruit a specialist, create an agent from an approved profile or reorganize work within explicit policies and budgets.

Decisions can come from an authorized agent, a person, a collective or local policy. Approval, execution permission and the resulting effects remain separate, inspectable steps.

Opt-in capability · V1–V8 implemented in source. Production readiness and organizational improvement require deployment-specific evidence.

The operating foundation

The platform beneath resilient collective operations.

Collective resilience is not a library call. It requires a common operating layer for applications, humans, workflows, memory, agents, models and infrastructure.

01

Applications

Product surfaces, customer workflows and internal tools built on top of the platform.

02

Human Interface

Approvals, escalations, collaboration, review queues and operational handoffs.

03

Workflow Engine

Durable orchestration for long-running tasks, retries, branching and policy gates.

04

Memory

Scoped context, state, artifacts and retrieval boundaries for each tenant or process.

05

Agent Runtime

Lifecycle, tools, identity, limits, execution state and deterministic audit capture.

06

Model Providers

Provider-neutral model access across inference, embeddings, routing and evaluation.

07

Infrastructure

Cloud services, storage, queues, secrets, observability and deployment primitives.

Integration responsibilities

Because reliable collective autonomy needs operational control.

The hard part is not adding agents. It is keeping their coordination, authority, recovery and protected actions reliable when conditions change.

Your application

deployment owner
  • -Supplies the product UI, business logic and external connectors.
  • -Operates storage, backups, model providers and verified identity.
  • -Connects approval policy and checkpoints to protected effects.
  • -Tests its failure boundaries and reconciles ambiguous outcomes.

AgentPlat

control plane
  • +Coordinates agent groups through runtime, policy and bounded local state.
  • +Models failures and recovery as first-class operational events.
  • +Provides opt-in authority, fencing and execution checkpoint contracts.
  • +Lets teams operate collective autonomy with clear accountability.

The capabilities behind the promise

Composable capabilities for human–agent applications.

AgentPlat brings coordination, control and evidence together with the platform components product teams need to operate them.

C

Coordination

Bounded local collaboration, shared state and collective planning.

R

Recovery

Assignment, membership and communication recovery after failures.

M

Memory

Scoped context, artifacts, retrieval and tenant boundaries.

F

Fenced Actions

Protected effects bound to identity, authority and current assignment.

T

MCP and Tools

Standardized access to tools, services and external systems.

A

Audit Evidence

Traceable decisions, recoveries, tool calls, approvals and outcomes.

W

Workflows

Durable orchestration for complex business processes.

H

Human Collaboration

Review queues, escalations, approvals and shared accountability.

I

Identity

Users, tenants, agents, roles, permissions and execution scopes.

O

Observability

Metrics, traces, quality signals and collective runtime health.

D

Deployment

Environment-aware packaging for platform and product teams.

P

Policy

Limits, approvals, data rules and operational guardrails.

Success stories

Their next chapter.
Built with AgentPlat.

Different products. Different ways to turn AI into something people can use. Discover the AgentPlat contribution behind each experience.

Healthcare

Kidney Connective

AgentPlat brings execution controls and traceability to AI-assisted patient profiles and transplant-center matching.

Read the story
AI simulations

Simultrix

AgentPlat powers the agent execution behind Simultrix’s simulated focus groups and bilateral negotiations.

Read the story
Legal technology

No Firmes

Built on AgentPlat’s application platform, No Firmes connects document intake, specialized AI analysis and report delivery.

Read the story
Creator marketing

Pooshlo

Pooshlo combines AgentPlat-powered matching and product discovery with profile audits and content collection in an operating system for creator marketing.

Read the story
Media · Daily Brief

El País

Grishen used AgentPlat as the design foundation for Daily Brief, turning El País’s reporting into AI-generated summaries for different audiences.

Read the story
E-commerce · Agent Rooms

Trafilea

After using AgentPlat directly in 2025, Trafilea began developing its own implementation in 2026, drawing on Agent Rooms and targeting an 80% agentic e-commerce operation.

Read the story
Explore success stories What could we build for you? →

Used By

Companies that have built with AgentPlat.

AgentPlat has supported enterprise workflows, vertical products and customer-facing platforms across finance, commerce, healthcare and legal operations.

Architecture

A control plane for collective autonomy.

Use AgentPlat as the shared layer between agents, application teams and infrastructure. Coordination stays local and resilient while operational controls remain consistent.

Product Surfaces
Web AppsAdminAPIsEmbeds
Human Layer
ReviewApprovalsEscalationsInbox
Collective Core
CoordinationRecoveryMemoryPolicyAudit
Integration Layer
MCPToolsEventsConnectors
Foundation
ModelsQueuesStorageSecretsTelemetry
terminal deterministic collaboration example
git clone https://github.com/Agentplat/agentplat.git
cd agentplat/examples/rooms-api
cp .env.example .env
docker compose up --build -d --wait
node scripts/proposal-demo.mjs
# Requires Git, Node.js 22.13+ and Docker Compose v2.
# Scripted review; no live model calls by default.

Architecture and evidence

Scale is designed in—and validated separately.

AgentPlat distinguishes architectural capacity from demonstrated results, so product teams can evaluate each claim precisely.

100,000 agents

design capacity
  • +Sparse peer views and bounded local coordination are designed for collectives of up to 100,000 agents.
  • +The architecture avoids requiring every agent to communicate with or observe the entire collective.

Control at every boundary

Designed for teams that cannot afford fragile autonomy.

Agentic systems need the same seriousness as any other critical infrastructure: identity, authority, fault tolerance, auditability and operational ownership from the beginning.

  • 1
    Fault-aware operationsExpected peer, capability and network failures are observable operating conditions.
  • 2
    Controlled authorityPolicy, identity and fenced assignments sit inside the action boundary.
  • 3
    Operational evidenceTeams can inspect decisions, recoveries, failures and protected outcomes in one place.
  • 4
    Platform leverageBuild many resilient collective products on one shared control plane.

Where collective operations matter

For work that cannot stop when one agent fails.

AgentPlat is built for operations where multiple specialized agents must coordinate safely across systems, teams and changing conditions.

Incident response

Coordinate specialized agents across evolving incidents while preserving authority and evidence.

Complex operations

Operate long-running, multi-system work where peers can fail and priorities can change.

High-stakes automation

Run governed collective automation across existing tools without losing control or traceability.

Principles

Built for dependable collective operations.

AgentPlat is an operational foundation for dependable collective operations—not a prompt demo. It gives teams the structure to build reliable multi-agent systems.

  • A
    Local over broadcastBounded coordination gives collectives a scalable and inspectable operating shape.
  • B
    Recoverable over brittleFailure and reassignment belong in the system model, not in an incident playbook.
  • C
    Verifiable over opaqueProduction autonomy requires evidence that people and systems can inspect.
  • D
    Controlled from day oneAuthority, identity, review and observability are core architecture concerns.

Evaluate AgentPlat

Run the examples and inspect the evidence.

Start with one workflow, verify its behavior and review the integration obligations for your application.

Persistent collaboration

Run a two-agent proposal, request a revision and inspect the retained artifacts and approval.

Run the guide →

Human approval

Distinguish artifact review from protected execution. Check a provider checkpoint and local effect receipt.

Check approval controls →

Evidence and limits

Separate source behavior, package distribution, research and observed operational results.

Inspect the evidence →

Archived model commentary

Project-requested model commentary is not an independent evaluation, vendor endorsement or production validation.

Read the archived commentary →

Articles

Understand the work behind agent collaboration.

Practical guides to shared work, human decisions and process recovery. Explore all articles →

Human approval in AI agent workflows

Understand the difference between accepting an artifact and authorizing an external action.

Read the approval guide →

Recovering agent work after a failure

Learn how stable identities and retained results help a successor reuse completed work.

Read the recovery guide →

Contact

Talk to the team building AgentPlat.

Share what you are building, the platform constraints you have and the kind of agentic system you want to operate.

Start Building

Turn isolated agents into resilient collective operations.

Use AgentPlat to coordinate autonomous agents safely, recover from failure and verify every critical outcome.