The platform for building and operating AI products.

Persistent workspaces, governed agent teams, resilient coordination, and auditable execution—across any model, tool, or infrastructure.

Open-source and self-hosted: you deploy AgentPlat in your own infrastructure and operate your own application, data, identity, model providers and policies. AgentPlat does not offer a hosted product, shared API, dashboard or managed runtime.

Start Building Read the Docs For AI coding agents GitHub

Open framework npm install @agentplat/framework

Fault-tolerant coordination Collectives recover when peers, links or capabilities fail.

Bounded autonomy Local coordination scales without fragile all-to-all orchestration.

Verifiable operations Every decision, recovery and protected action is attributable.

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.

Typical multi-agent stack

fragile scale

-Broadcasts tasks or context across an unbounded group.
-Treats peer, network and capability failures as application exceptions.
-Leaves authority, recovery and protected actions to custom glue code.
-Produces outputs without a complete operational evidence trail.

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.
+Fences protected actions with policy, identity and verifiable authority.
+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 →

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.

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.

Applications

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

Human Interface

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

Workflow Engine

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

Memory

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

Agent Runtime

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

Model Providers

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

Infrastructure

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

A control plane, not a prompt loop

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.

Typical agent framework

demo layer

-Focuses on chains, prompts and one-off task delegation.
-Leaves resilience, identity and recovery to the application team.
-Assumes safe action control is an integration detail.
-Optimizes for assembly more than dependable collective operation.

AgentPlat

control plane

+Coordinates agent groups through runtime, policy and bounded local state.
+Models failures and recovery as first-class operational events.
+Protects actions with authority, fencing and auditable execution traces.
+Lets teams operate collective autonomy with clear accountability.

The capabilities behind the promise

Everything required to operate a resilient collective.

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

Coordination

Bounded local collaboration, shared state and collective planning.

Recovery

Assignment, membership and communication recovery after failures.

Memory

Scoped context, artifacts, retrieval and tenant boundaries.

Fenced Actions

Protected effects bound to identity, authority and current assignment.

MCP and Tools

Standardized access to tools, services and external systems.

Audit Evidence

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

Workflows

Durable orchestration for complex business processes.

Human Collaboration

Review queues, escalations, approvals and shared accountability.

Identity

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

Observability

Metrics, traces, quality signals and collective runtime health.

Deployment

Environment-aware packaging for platform and product teams.

Policy

Limits, approvals, data rules and operational guardrails.

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.

Santander

El Pais

Trafilea

Pooshlo

Kidney Connective

NoFirmes.com

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

platform.ts typed runtime

import { platform, workflow } from "@agentplat/framework";

const collective = workflow("operations-cell")
  .memory({ scope: "tenant" })
  .policy({ protectedActions: "fenced" })
  .recovery({ peer: "enabled", network: "enabled" })
  .audit({ trace: "verifiable" });

platform.deploy(collective);
// Coordinate locally. Recover safely. Prove every outcome.

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.

500 agents

validated scale

+Fault-tolerant collective operation has been validated across 500-agent scenarios.
+Review the evaluation model, evidence boundaries and limitations →

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.

Independent perspectives

What leading AI models think about AgentPlat.

We asked OpenAI Codex, Anthropic Claude, Grok and DeepSeek to analyze the codebase deeply and share their perspective.

OpenAI Codex

“An unusually ambitious and thoughtful foundation for building serious agentic systems.”

View all opinions →

Anthropic Claude

“AgentPlat starts from who is accountable for what an agent did, and what evidence survives the fact.”

View all opinions →

Grok

“AgentPlat treats governance as the product, not as an afterthought bolted onto a chat loop.”

View all opinions →

DeepSeek

“AgentPlat provides a genuine architectural backbone for systems that are maintainable, auditable, and scalable.”

View all opinions →

Cursor Composer

“AgentPlat treats agentic software as infrastructure, not as a chat product.”

View all opinions →

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.

Read the Docs View the Open Framework