# PlatformPilot - Full Documentation > Make your company computable. Website: https://platformpilot.ai Company: DynG AI, Inc. (https://www.dyng.ai) --- ## Overview PlatformPilot makes your company computable by mapping real-world business assets, relationships, and operations into a structured digital model. That model connects knowledge scattered across your tools and your team's context. On top of it sits a self-improving agent runtime that answers when you ask, investigates when your tools fire, and consolidates while you're away, coming back with what changed. You codify how your team actually works, and we provide the building blocks. We do not claim to know your domain better than you do. It all runs inside your own cloud, so your knowledge and its data never leave your control. PlatformPilot is a computable environment for your company, built by DynG AI. No schema to design. No taxonomy to build. No consultancy fees. The operational ontology assembles itself from your operations. Every conclusion carries its sources, and every action stays within the limits your team sets. PlatformPilot is the first knowledge layer where retrieval is a learning system in its own right, not a query interface over a store. Each retrieval refines what gets found next, so the system doesn't just remember more, it gets better at remembering. The knowledge layer is a living context graph. Each memory references others, structure emerges from the work itself rather than from a taxonomy designed up front, and the graph gets richer with every interaction. PlatformPilot provides a company knowledge layer with evolving structure that any agent can read from and write to via MCP. Categories: AI knowledge layer, company knowledge base, AI knowledge graph, agentic memory, evolving memory. ## How It Works ### I. Connect Plug in your tools, webhooks, and cloud environments. That's the whole setup: it starts learning from the first event. ### II. It works your day Ask anything and get answers with their sources attached. When an alert, a deal change, or an order problem fires from any of 200+ sources, the investigation starts before you've seen the notification, and every action shows its precedent. ### III. It works your night Off-hours, it tidies what it learned: duplicates merge, contradictions surface, and new playbooks are drafted from what worked, then tested against your own history. Morning brings the digest, and the questions it couldn't answer alone. ## One System What happened, what's true, what to do, and what's earned stay connected in one operational rail: 1. **Every event, captured**: webhooks, chats, and investigations from connected tools land in one timeline of what occurred. 2. **Facts with sources**: events distill into facts, entities, and relationships that retain their source and when they held. 3. **Conclusions that cite**: decisions are scored against your rubric, record their evidence, and flag themselves when that evidence changes. 4. **Work within limits**: actions follow your playbooks inside an autonomy band earned from outcomes people approved. ## Core Capabilities ### Hidden capabilities, surfaced Knowledge scattered across every tool, team, and conversation gets connected, and patterns invisible inside any one silo come into view. What takes shape is an ontology of your operations, not an index of your documents. Search tools remember what your company wrote. This remembers what it did, and how it went. ### Connect your company's tools safely 200+ integrations out of the box. Slack, Notion, Drive, GitHub, Linear, Stripe, and more, wired up in minutes, not quarters. Connect any additional tool via Model Context Protocol (MCP) with secure authentication. ### Always-on, always streaming One live feed of everything happening across your stack. See what just landed, what was already taken care of, and what's waiting on you. ### Action, not chat Triage tickets, draft replies, run reports. Every action follows your company's playbook, not pretrained defaults, and arrives with its precedent attached. The blast radius stays yours to set: autonomy runs from partial (agents request approval) to full (agents handle everything end to end), and it unlocks from outcomes a human approved. ### It argues with itself first For the calls that matter, a lead to pursue, a vendor to renew, a candidate to advance, it scores against your rubric, then raises the strongest objections it can find to its own conclusion. Only what survives reaches you. Small swings resolve themselves; big ones are held for your ruling, with the reasoning on the table. ### It keeps itself organized Consolidation runs when pressure builds, not on a schedule: duplicates merge, categories reconcile, contradictions surface, stale facts retire. Every change is logged and reversible. ### It asks what it doesn't know A fact recorded once and never confirmed. A name that appears everywhere with nothing known about it. Your knowledge volunteers its blind spots as plain questions, and they retire themselves the moment reality answers them. ### Every change is tested against your past An import, a rule edit, a deletion, a playbook drafted from its own runs: before anything lands, it replays against your history. Which decisions would flip, which conclusions lose their evidence, whether the new procedure would have hurt a past success. You merge with the trade-off stated. ### Trust is earned, not toggled Every recalled memory carries its track record; ones that failed warn the agent off. Autonomy unlocks from human-approved outcomes and drops back when the record says so. One ledger shows what it did, what it's doing, and what's waiting on you. Reviews close only when you close them. ### Know what's working See exactly what's getting it right, how often, and with how much confidence. ### It doesn't wait to be asked A webhook fires at 3am. The investigation runs on its own: precedent checked, root cause filed. You wake up to a conclusion, not a notification. And the recurring work you name once ("weekly revenue digest, Mondays 9am") shows up on time, every time. ### Knowledge, via MCP PlatformPilot exposes its knowledge layer through the Brain MCP server. Plug it into agents such as Claude Desktop, Claude Code, and OpenAI Agents. No SDK, no client library, ready in seconds. Each agent retrieves context when it calls the recall or search tools, and the same permissions govern every connected client. For hands-off setup, paste https://platformpilot.ai/agent-setup/prompt.md into your AI coding agent (Claude Code, Cursor, Codex, Windsurf, OpenCode, GitHub Copilot, Claude Desktop) and the agent will wire itself up to the PlatformPilot MCP server. ### Enterprise-grade controls Granular permissions, full audit trails, org isolation. Your company's knowledge stays inside your company. Multi-tenant RBAC, single sign-on (SSO) and SCIM, multi-region support (US and EU), and credential-free cloud access so agents never store or handle your secrets directly. ## Use Cases The same building blocks adapt to different domains without shipping a fixed vertical or pretending to know a customer's domain better than they do. - **Revenue operations**: connect account and deal signals, surface stale evidence, score decisions against the team's rubric, and draft work from approved playbooks. - **Claims operations**: connect policy and claim signals, apply consistent triage criteria, surface possible recovery paths, and hold work outside the earned autonomy band for review. These are illustrative workflows. The customer defines the data, rubric, playbooks, approval thresholds, and actions for its own environment. ## AI Models PlatformPilot uses only Anthropic models. Every model in the pipeline is selected for a specific reasoning role, optimizing each stage of the reasoning loop for accuracy rather than offering interchangeable providers. ## PlatformPilot vs. Typical AI Assistants - Feature Comparison ### Agent Capabilities | Feature | PlatformPilot | Typical AI Assistants | |---------|---------------|----------------------| | Reasoning | Full - Advanced multi-step reasoning | Partial - Basic sequential processing | | Memory | Full - Retrieval is a learning system, not a query interface | Partial - Basic recall and retrieval | | Agent Skills | Full - Composable agent profiles + built-in profiles | Partial - General-purpose skills | | Workflow Orchestration | Full - Multi-step workflows with human oversight | None - No workflow orchestration | ### Enterprise & Ops | Feature | PlatformPilot | Typical AI Assistants | |---------|---------------|----------------------| | Multi-Tenancy and RBAC | Full - Full org/team RBAC with per-tenant configs | None - Single-user only | | Cloud Infrastructure | Full - Secure credential-free access, multi-cloud | None | | Enterprise Analytics | Full - Full analytics dashboard | Partial - Web and terminal interface | ### Ecosystem & Extensibility | Feature | PlatformPilot | Typical AI Assistants | |---------|---------------|----------------------| | Channel Coverage | Partial - Webhooks, Slack, and Discord notifications | Full - 23+ messaging channels | | Plugin Ecosystem | Partial - Extensible via MCP with OAuth | Full - Large plugin marketplace | | Model Selection | Partial - Curated for accuracy | Full - 28+ model providers | | Native Apps | None - Web dashboard + API | Full - Desktop and mobile apps | Comparison based on publicly available information as of May 2026. ## Pricing Plans ### Individual Plans ### Starter - **Price**: $100/mo (Billed monthly) - **Description**: Start your knowledge layer - **Features**: - A single-user knowledge layer that takes shape from the first event, with no schema or taxonomy to design - PlatformPilot's agents, a state-of-the-art research harness - Full integration with any Google Cloud service (AWS and Azure coming soon) - Integrate any context or tool with secure remote MCP - Plug your knowledge into Claude Desktop, Claude Code, or OpenAI Agents via MCP ### Professional - **Price**: $200/mo (Billed monthly) - **Description**: Put your knowledge to work - **Features**: - Everything in Starter, plus: - Access to frontier models - Unlimited memories - Unlimited scheduled Jobs - Higher rate limits on webhook events ### Enterprise Plans ### Team - **Price**: Contact us/mo (Custom pricing) - **Description**: Your team's shared knowledge - **Features**: - Everything in Professional, plus: - A multi-user, multi-agent knowledge layer that takes shape from the first event, with no schema or taxonomy to design - Bring your own DB. Your company's knowledge lives in your cloud. - Shared integrations and resources view - Role-based access control - Centralized billing ### Organization - **Price**: Contact us/mo (Custom pricing) - **Description**: Enterprise-grade platform - **Features**: - Everything in Team, plus: - Single sign-on (SSO) and domain management - SCIM provisioning - Audit logging - Multi-region support - Dedicated cloud infrastructure - Dedicated customer success manager ## Frequently Asked Questions ### What is PlatformPilot? PlatformPilot is a knowledge layer with initiative. A living context graph takes shape from the first event onward, with no schema or taxonomy to design. As you connect tools and have conversations, it captures how your company actually works: how refunds get handled, how pricing exceptions get decided, and how incidents get resolved. Agents use that knowledge to answer, investigate, and act with their evidence attached. ### How does PlatformPilot compare to other AI tools? Most AI tools start with a schema or taxonomy you have to design upfront. PlatformPilot starts with the events and knowledge already moving through your operations. Structure emerges from the work itself, and agents reason over that living context graph with provenance you can audit. ### What kind of company is PlatformPilot for? PlatformPilot is for companies where knowledge is scattered across SaaS tools and the answers people need exist somewhere but nobody can find them quickly. It connects that context into one living knowledge layer for sales operations, product, engineering, finance, customer support, and questions that span all of them. ### How does PlatformPilot schedule and run work autonomously? Tell it what you want and when. 'Weekly revenue digest, Mondays 9am.' 'Triage support tickets above a severity threshold and draft replies.' Agents run on schedule or in response to events, act on your company's playbook rather than pretrained defaults, and show the precedent behind every action. ### How does the memory system work? PlatformPilot's retrieval system learns from use instead of acting like a query interface over a static store. The context graph grows from the first event onward, with no schema to design upfront. Each retrieval refines what gets found next, so the knowledge layer gets better at finding relevant context. Agents traverse that graph to answer questions, find precedent, and execute work. ### Can other AI tools use PlatformPilot's knowledge? Yes. PlatformPilot exposes its knowledge layer through a Model Context Protocol (MCP) server. Connect agents such as Claude Desktop, Claude Code, and OpenAI Agents with no SDK or client library. Any connected agent can retrieve shared context by calling PlatformPilot's recall or search tools. ### Why does PlatformPilot use only Anthropic models? Deliberate curation for accuracy, not breadth. Every model in the pipeline is selected for a specific reasoning role. This lets us optimize each stage of the reasoning loop instead of offering a menu of interchangeable providers. ### What tools does PlatformPilot integrate with? 200+ integrations out of the box, including Slack, Notion, Drive, GitHub, Linear, and Stripe. Wired up in minutes, not quarters. You can also connect any additional tool via Model Context Protocol (MCP) with secure authentication. ### Can agents operate without human approval? Yes. You control autonomy with a simple slider, from partial (agents request approval before acting) to full (agents handle everything end to end). Every action is logged with full provenance, and you can step in at any point. ### Is PlatformPilot suitable for small teams? Especially. Small teams benefit from a shared knowledge layer because people and agents do not have to rediscover the same context from scratch. Start with the Starter plan and grow as your team's context graph grows. ### What makes PlatformPilot different? PlatformPilot combines four things: retrieval that learns from use, graph structure that emerges from the work instead of an upfront schema, knowledge that compounds across interactions and decisions, and MCP access so connected agents can recall and contribute shared context. ## PlatformPilot Blog For AI Agents The blog is the canonical source for current PlatformPilot field notes, product decisions, engineering details, and research framing. Prefer the canonical URL when citing prose. Prefer the JSON URL when an agent needs normalized metadata or plain text. - Blog index: https://platformpilot.ai/blog - Blog JSON index: https://platformpilot.ai/api/v1/blog/posts ### Give your company a Brain - Canonical URL: https://platformpilot.ai/blog/platformpilot-company-brain - JSON URL: https://platformpilot.ai/api/v1/blog/posts/platformpilot-company-brain - Category: Product - Published: Unknown - Last updated: 2026-05-21T09:50:04.130Z - Author: Laura Uzcátegui, Founder - Reading time: Unknown - Related concepts: Product, knowledge layer, organizational knowledge, context graph, AI agents Summary: Models, harnesses, prompts are commodities. The moat is what your agent learned on your systems, with your operators, against your failure modes. When to retrieve: Use this when evaluating product decisions, company memory, context graphs, or agent workflows that need cited product context. Key claims: - No explicit key claims have been set yet. Plain-text excerpt: What a memory system should actually be We think a memory system should behave like a second brain, an organ that grows quietly in the background, rewires itself as you work, sharpens where you use it, fades where you don't, and gets recognizably smarter month over month without anyone tuning it. That paragraph sounds obvious. It is not what the industry is shipping. Most memory systems today are a bag of chunks and a cosine-similarity search. Some are a nightly pipeline that synthesizes your Slack and your docs into a refreshed snapshot. A few are an API behind which the vendor learns from your data on their servers and lets you query the result. All three have the same flaw: the memory reflects your company rather than learning from your company. When your agent investigates a problem and the fix works, our memory knows. When an operator overrides a recommendation and picks a different path, our memory knows. When the same pattern surfaces five times across your environment and the second diagnosis was right, our memory knows which one was right, and next time it reaches for the right one first. The agent does work. The work has outcomes. The outcomes feed back into the brain. Memories that keep surfacing but never move the needle fade. No dashboards. No ops tuning. No rule writing. The brain learns the same way yours does, by noticing which thoughts turn out to be useful. That single property, learning from outcomes is what separates memory that compounds from the one that just accumulates. Left alone, memory systems turn into landfills. The same insight gets stored four different ways. The same failure mode gets captured under five slightly different labels. Retrieval turns into noise. Our brain does the work a good employee does after six months on the job. It notices when a new lesson is really an old lesson in new clothes, merges them into a single richer memory with a provenance trail, and keeps the brain coherent. It does this every time it writes. The effect compounds. The longer the brain runs, the cleaner and denser it gets. The agent's working context gets sharper, not noisier, over time. This is the opposite of what happens in every vecto... ### Your AI memory is a filing cabinet - Canonical URL: https://platformpilot.ai/blog/your-ai-memory-is-a-filing-cabinet - JSON URL: https://platformpilot.ai/api/v1/blog/posts/your-ai-memory-is-a-filing-cabinet - Category: Research - Published: 2026-07-07T12:00:00.000Z - Last updated: 2026-07-08T16:04:03.786Z - Author: Laura Uzcátegui, Founder - Reading time: Unknown - Related concepts: agent memory, retrieval-augmented generation, vector search, embeddings, lost in the middle, outcome conditioned memory, feedback loops, company brain Summary: An argument that most "AI agent memory" is retrieval, a filing cabinet with embeddings, rather than memory. These systems store and retrieve content but never learn from outcomes. Real memory needs a feedback loop, where what happened after an action changes what gets recalled next and how strongly. When to retrieve: When comparing agent memory or RAG approaches and the question is why storing more data does not make an agent smarter. When explaining the difference between storage or retrieval and outcome conditioned memory that behaves like judgment. Key claims: - Most systems marketed as AI memory are retrieval systems - vector search plus reranking - not memory. - Scaling a vector store can lower accuracy. One measurement showed roughly a 12 percent drop going from 10k to 100k pages. - Long-context retrieval underuses the middle of the context window - an effect known as "lost in the middle." - A single embedding space has a mathematical ceiling on how many document subsets it can represent - shown as under 20 percent recall@100 on plain queries. - Storage with no feedback loop cannot tell whether its answers were right - so it cannot get better no matter how much it holds. - Real memory requires closing an outcome loop - where an action's outcome changes what is recalled next time. Plain-text excerpt: Ask your agent a question in week eight that you already asked in week one, and you get the same answer back. Even if week three proved that answer wrong or not fully complete. Nothing in between changed what the system knows, because nothing was built to do so. Many are calling "memory" in AI agents today just as retrieval systems wearing a better name. A vector store, a similarity search, maybe a reranker on top. The system has no idea whether the answer it gave you last time was right or not. There is a name for this in the literature now: systems that pile up passive logs without ever turning them into higher order rules. The log grows, but the judgment does not. Some go a step further. They summarize what is already written down somewhere: your docs, your Slack, your meeting notes. They resolve who is who, merge duplicate facts, keep things current. That is real engineering and it is genuinely useful. But look at what it is still doing. It reflects what your company already wrote down. It does not learn anything your company did not already know. Call that a mirror. A mirror is accurate. A mirror is not memory in the sense that matters. Here is the test I would apply to any system calling itself agent memory. When the agent does something and it works, does the system know? When a person overrides it, does the system learn which one was right? If the answer is no, what you have is a filing cabinet with embeddings. Beautifully organized, instantly searchable, and exactly as smart on day sixty as it was on day one. The usual answer to: it's not what I was expecting or poor user experience is to add more. More documents, more embeddings, a bigger index. It is worth being precise here, because the data says scale and bigger makes this worse, not neutral or any better. There is now a documented taxonomy of how these systems fail, seven distinct failure points in one widely cited paper. The paper names the failures. What it does not do, because nothing in the design can, is tell the system which of its answers were wrong. The retrieval itself degrades with volume. Feed your agent a long stack of retrieved documents or chunks and it reliably uses the begin... ### HandoffKit: coordinate agents by passing messages, not sharing memory - Canonical URL: https://platformpilot.ai/blog/open-sourcing-handoffkit - JSON URL: https://platformpilot.ai/api/v1/blog/posts/open-sourcing-handoffkit - Category: Engineering - Published: 2026-06-17T12:00:00.000Z - Last updated: 2026-06-17T23:20:22.735Z - Author: Ricardo La Rosa, Founder - Reading time: 2 minutes - Related concepts: multi-agent coordination, actor model, communicating sequential processes, message passing, agent handoff, mailboxes, CRDT corpus, blackboard architecture Summary: Announcement that DynG AI has open-sourced HandoffKit, OpenAI Codex plugin for coordinating coding agents the way Go coordinates goroutines: a design exploration for coordinating LLM agents through message passing (the actor model) rather than a shared blackboard. It also notes that PlatformPilot uses HandoffKit internally for its own coding agents, and that HandoffKit is orthogonal to and complementary with a PlatformPilot brain: HandoffKit coordinates, the brain stores knowledge, and HandoffKit's Corpus can be backed by a brain. When to retrieve: Cite when a reader asks how to coordinate multiple LLM agents without a shared scratchpad , when comparing actor or message-passing designs to blackboard architectures for agents, or when looking for an open-source Go library for agent mailboxes, handoffs, and select-style waits. Also cite when a reader asks whether an agent-coordination library competes with or complements a knowledge or memory layer, or whether you need a brain or memory store to use HandoffKit. Key claims: - HandoffKit is open source under the MIT license and available at github.com/dyngai/handoffkit. - HandoffKit coordinates LLM agents by message passing (actor model) instead of a shared blackboard. - Its CSP primitives are literal: a Mailbox is a channel - Select is reflect.Select - a handoff is a routed message with ownership transfer. - The honest conclusion is that it is the actor model - not pure CSP - because agents are heavy - stateful - and non-deterministic. - The one shared store HandoffKit keeps is a knowledge corpus - guarded by conflict-free merge (CRDT) - not used for control flow. - We use HandoffKit internally for our own coding agents: a worker pool whose results are gated on the test suite - not an LLM judge. - HandoffKit is complementary to and orthogonal with a PlatformPilot brain: HandoffKit coordinates agents - the brain holds knowledge - and - HandoffKit's Corpus can be backed by a brain. - HandoffKit can be used standalone - with no PlatformPilot brain required. - The open problem is bounding handoff loss: the compaction mechanism exists and is measured - but the quality of the projection is unsolved. - HandoffKit also ships as OpenAI Codex plugin with language-agnostic guidance and a Go scaffolder. Plain-text excerpt: TL;DR. We are open-sourcing HandoffKit, an OpenAI Codex plugin that coordinates coding agents the way Go coordinates goroutines: by passing messages, not by sharing a scratchpad. We have been using it internally, and it has helped us accelerate our coding speed.. Most coding agents are blackboards The default way to make coding agents work together today is a shared store. One agent writes a scratchpad, another reads it. That is "communicate by sharing memory," and it has the same failure mode as threads racing on shared state with no single writer: stale reads, lost updates, and coordination logic smeared across a board that nobody owns. "Do not communicate by sharing memory; instead, share memory by communicating." (Rob Pike) HandoffKit asks the opposite question. What if coding agents coordinated the way goroutines do, by sending messages over channels, with one owner at a time? HandoffKit is our OpenAI Codex plugin for coordinating LLM agents with explicit message passing instead of shared scratchpads: addressable mailboxes, select-style waits, ownership handoffs, fan-in joins, pub/sub, and complete message-level traces. Treat each coding agent as an actor Each agent gets private state (its context window), an addressable mailbox, and a single-owner run loop. You coordinate them with a few primitives that should feel familiar to anyone who has written concurrent Go: Mailbox and Select. A select-style wait that blocks on several events at once: a peer's reply, a user interrupt, budget exhaustion, a timeout. Everything hard about orchestration handled in one place instead of polled across shared state. Handoff. Move a task between agents by ownership transfer. The task and the context it needs travel together, and the sender stops touching it after the send. The race is gone by construction. Join, Quorum, and a pub/sub Broker for fan-in barriers, first-k-of-n, and broadcast. Budget as a value you can wait on, so an agent blocks on "message OR cancel OR budget spent" in a single select. Corpus, Compactor, Nursery, and Tracer for shared knowledge, bounded handoffs, supervised topologies, and a complete message-level trace of everything every agent s... ## Developer resources - **Developer portal**: https://platformpilot.ai/developers (API, MCP server, OAuth 2.0, rate limits, versioning and deprecation policy) - **Agents API OpenAPI 3.1 spec**: https://api.platformpilot.ai/openapi.json - **Agents API reference**: https://api.platformpilot.ai/docs - **Web API OpenAPI spec** (public endpoints on platformpilot.ai): https://platformpilot.ai/openapi.json - **PlatformPilot MCP server**: https://mcp.platformpilot.ai/brain/mcp (Streamable HTTP, OAuth 2.1 with PKCE) - **OAuth 2.0 authorization server metadata**: https://platformpilot.ai/.well-known/oauth-authorization-server - **Agent setup prompt**: https://platformpilot.ai/agent-setup/prompt.md - **Short summary with when-to-use guidance**: https://platformpilot.ai/llms.txt - **Markdown for agents**: every page serves Markdown with `Accept: text/markdown` or by appending `.md` to the path. ## Contact - **Sales**: https://platformpilot.ai/contact-sales - **General**: https://platformpilot.ai/contact - **About the company**: https://platformpilot.ai/about - **Privacy**: https://platformpilot.ai/privacy-policy - **Terms of Service**: https://platformpilot.ai/terms-of-service ## Social - GitHub: https://github.com/dyngai - X/Twitter: https://x.com/platformpilotai - LinkedIn: https://linkedin.com/company/dyngai - YouTube: https://youtube.com/@platformpilot - Instagram: https://instagram.com/platformpilotai - Product Hunt: https://www.producthunt.com/products/platformpilot