Platform Overview

KeenAgents lets your organization build AI agents, group them into spaces, and offer them to your own customers through a secure API. Administrators manage everything from the admin console. Its sidebar has four groups — Organization (Accounts, MCP Accounts, Roles), Ai (Spaces, Agents, Consumers, MCP Consumers), Api (Api Keys, Clients, Certificates, Contracts, Webhooks) and System (Logs, Log Records, Cache) — and each entry appears only for roles that can read that area. Partner applications talk to the platform over HTTPS and WebSocket using standard credentials, and an AI agent working on your behalf can operate the same console through the Keen MCP server, under a credential and role you give it. Every rule you read in these docs is enforced by the platform itself: the console gives you instant feedback, but the final decision on every action is made server-side, and every decision is recorded.

Organization

Your team's roles and admin accounts. Roles grant read or write on each of fourteen permission scopes — roles, account, consumer, spaces, agents, api_keys, clients, certificates, contracts, webhooks, cache, logs, mcp_accounts and mcp_consumers — and write always includes read; protected built-in roles cannot be removed. New team members confirm their account and set their password through emailed links — the link itself is the credential, so no admin ever handles another person's password. While you keep working, the console keeps you signed in on its own. After a period of inactivity a Session Expired panel asks for your password in place — you continue exactly where you were. After a longer absence, or three wrong passwords in that panel, you sign in again from the login page. How long each window is depends on how your KeenAgents environment is configured. Alongside people, the organization can hold MCP accounts: logins for AI agents rather than humans. An MCP account has a name, a role and an Enabled switch, but no email or password — its credential is an id plus a one-time secret you copy at creation (and can rotate later). Its name is unique and fixed at creation. Only humans manage MCP accounts; an MCP account can look them up but never create, change or delete one — nor any human account or role — whatever its role.

AI Spaces & Agents

Spaces group your agents and carry a deployment token you can copy or reset — resetting immediately invalidates the previous token, so a leaked token dies the moment you rotate it. Agents have a human display name and a URL-safe agent id (the create form derives the id from the name as you type), an Active toggle, and two dedicated settings editors: JSON Settings and Front Settings. Deleting a space is a deliberate two-step action and also removes the agents inside it.

API access for partners

Partner applications integrate over HTTPS and WebSocket using API keys, client credentials and PEM certificates, in an OAuth-style two-token model. Requests are accepted only from origins you have allow-listed, credentials are verified on every single message — not just at connection time — and webhooks notify your application whenever relevant data changes so it can fetch the fresh state.

Consumers

The end users of your partner applications. KeenAgents handles their registration, sign-in, password reset and optional one-time-pin confirmation, runs their chat sessions with your agents, and keeps their conversation history — always scoped to your organization and never visible to any other tenant. Alongside them, MCP consumers are headless end users an AI agent creates for itself through the Keen MCP server — no email, no password and no one-time pin, just an id and a secret; they belong to a partner's consumer contract and reach some of that contract's spaces, and their tokens are issued only through the MCP server. In the console you can see them and, with the right permission, disable, re-key or delete one — never create one.

AI agents as operators

Your organization can be operated by an AI agent — an assistant such as Claude Code working on your behalf. It connects to the Keen MCP server at https://<your-host>/mcp, signs in with an MCP account's id and secret, and from then on has tools that mirror the admin console: it can create and edit spaces and agents (both settings channels included), build the partner access chain — certificates, clients, contracts, webhooks, api keys — rebuild the served copy bound to a key and wake the partner site, read the logs, and provision its own headless end users (MCP consumers). It acts strictly under the MCP account's role, every action is recorded like a teammate's, and it can never manage human accounts, roles or other MCP accounts, nor create human consumers. Tools that delete, rotate or reset something are flagged so the assistant asks you before running them.

Rules enforced server-side

The console mirrors validation for instant feedback, but every write is decided by the platform — a request that slips past the UI is still refused, and the refusal surfaces with the platform's own status and message. Unknown fields in an API request are rejected outright, so a typo can never silently do nothing.

Full audit trail

Every admin action is recorded: what happened and who requested it. The audit trail keeps recording even while parts of the platform are under maintenance — maintenance never creates a blind spot.

Tenant isolation

Your consumers, chats and credentials are yours alone. Every request — including every individual message on a live chat connection — is re-checked against the tenant it belongs to, so a token minted for one organization can never read or write another's data, even if credentials change mid-session.

Resilient by design

The platform stays responsive under load and recovers from brief disruptions on its own. No admin action is lost, and a refused request is refused cleanly: nothing is ever half-applied.

An agent runs a flow — a graph of nodes the platform walks one at a time. Some nodes call a language model, some run your own sandboxed code, and some route between them. You build a flow project and deploy it into a space; the platform security-scans it, and once it passes, the running system picks it up on its own — no restart, no downtime. Every node executes in its own isolated sandbox, so a failing node is contained rather than able to affect the platform or another conversation, and the platform runs many conversations at once, distributing and balancing the work for you.

End users chat with your agents in real time over a secure WebSocket, with the reply streaming back as it is produced. And while you build, you can debug the whole thing at the source level in a standard IDE — set breakpoints in your flow logic, your script code and your agent nodes, and step through a real run. See Building Agents for the full story, and Live Chat for the streaming surface.

• Destructive actions are two-step: deleting a space or an agent asks you to confirm before anything happens, and a space delete also removes its agents — so you always know the full blast radius before you commit.
• Secrets are shown once: an API key's secret, a client secret, an MCP account's or an MCP consumer's secret — copy it the moment it appears; the platform stores it irreversibly and cannot show it again, and rotating mints a new value while the old one dies at the same moment. A space's deployment token is the exception: it stays readable on the space's page and can be reset there.
• Password reset applies to confirmed accounts only — an account that never completed its confirmation link has nothing to reset, and the console tells you so.
• The Accounts, Consumers, MCP Accounts and MCP Consumers lists support paging, sorting and filtering, and the page and filters you are on live in the URL — refreshing or sharing the link keeps the exact same view. The Agents list is scoped to one space: pick the space, sort by any column, and the chosen space lives in the URL the same way.

Partner API endpoints cannot be tested by pasting the URL into a browser's address bar — the request is refused by design, because these endpoints only accept calls from origins your organization has allow-listed (or from your servers sending an explicit origin). Call them from your application code or an API client instead. This guardrail exists so that only the applications you have registered can ever reach your agents.

• Organization & Roles — permission scopes, protected roles, and inviting your team.
• Spaces & Agents — creating spaces, agent naming rules, deployment tokens, and the settings editors.
• Building Agents — how flows run node by node, deploying a project, and source-level debugging in your IDE.
• Partner API — API keys, certificates, the two-token model, webhooks, and the chat WebSocket.
• Consumers — registration, sign-in, password flows, and chat history from your end users' point of view.
• MCP Accounts — logins for AI agents: creating one, rotating its secret, disabling it.
• Keen MCP Server — connecting an AI agent to your organization and what it may do.
• MCP Consumers — the headless end users an AI agent provisions for itself.
• Resource Cache & Webhooks — Rebuild → Wake, the two clicks that push a change to a partner site.