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 — roles, team accounts, spaces, agents and their settings — while partner applications talk to the platform over HTTPS and WebSocket using standard credentials. 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 carry permission scopes with coupled read/write access; 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. An admin session lasts up to 7 days before sign-in is required again.

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.

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: when a credential is created or reset, copy it immediately — the platform stores it irreversibly and cannot show it again. Resetting mints a new value and kills the old one at the same moment.
• 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.
• Account and agent lists support paging, sorting and filtering, and the page you are on lives in the URL — refreshing or sharing the link keeps the exact same view.

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.