Integration

Kindo integration

Kindo is an AI platform for SecOps, DevOps and ITOps teams. List the models your organization allows and send OpenAI-compatible chat completions, create stateless or stored Chat Actions responses, read stored conversation items, list, create and run Kindo agents, follow a run to its result and its per-step evaluation verdicts, restart a run, and list or set the default integration connections agents use. Streaming (Server-Sent Events) is not exposed: every tool returns JSON. Authentication is a Kindo API key sent as a Bearer token in the Authorization header.

Connect Kindo How integrations work

Ask it in chat

Say what should happen.
The workflow builds itself.

When this happens, do that in Kindo.Built from the 16 Kindo tools below, on the connection you add once.

What you can do with Kindo

Each of these is one operation on one endpoint, available both as a workflow step and as a tool an AI agent can call on its own. Nothing bundles several operations into one action, so what a run did stays readable afterwards.

Most endpoints run on the free plan. A few, mainly the ones that publish on your behalf, need a paid plan.

Agent, 3 operations

create_agentCreate agentPOSTCreates an agent owned by the API key's user from an agent definition (an agent downloaded from Kindo, edited or not, or one written by hand) and returns its agentId; pass it to run_agent. Triggers are always created turned off.
get_agentGet agentGETReturns one agent's configuration: the input labels run_agent must match, models in use, triggers flag and recent run ids (5 with no query parameters; any of limit, cursor, startDate, endDate paginates them, 20 by default).
list_agentsList agentsGETLists the agents the API key's user can see, in one page capped at 500, each with its agentId, name, description, creator and the actions the caller may perform on it.

Agent run, 3 operations

get_agent_runGet agent runGETReturns an agent run's status (in_progress, success, failure or cancelled) and, on success, its result: a JSON-encoded string of the final assistant message. Call again while status is in_progress.
restart_agent_runRestart agent runPOSTStarts a new run of the same agent with the original inputs of the given run and returns the new runId at once; poll it with get_agent_run. The source run is unchanged; the new run uses the agent's latest version.
run_agentRun agentPOSTStarts an agent run and returns at once with its runId; call get_agent_run with it until status leaves in_progress. inputs[].name must match a label from get_agent's inputs; a missing required label is refused (422).

Conversation item, 2 operations

get_conversation_itemGet conversation itemGETReturns one item of a stored conversation by its id; its shape matches one entry of list_conversation_items data and depends on its type.
list_conversation_itemsList conversation itemsGETLists the items of a stored conversation (messages, reasoning, tool calls and their outputs), newest first by default. Page with after=last_id while has_more is true. Dispatch on each item's type.

Integration connection, 2 operations

list_integration_connectionsList integration connectionsGETLists the integration connections the API key's user can see, including shared group connections, each with its integration id and whether it is a preferred default.
set_default_integration_connectionSet default integration connectionPOSTMakes one connection the user's only default for an integration (replacing the whole default set). Get ids from list_integration_connections.

Response, 2 operations

create_responseCreate responsePOSTSends a message (OpenAI Responses shape) and returns the response; the text is output_text. Stateless by default; store=true, conversation or previous_response_id keeps a Kindo conversation. model agent/<uuid> runs an agent: poll get_response.
get_responseGet responseGETReturns a stored response by id, with its status and output_text. Use it to poll an agent-backed response (id resp_run_<runId>) until status is no longer in_progress.

Agent run evaluation, 1 operation

get_agent_run_evalsGet agent run evalsGETReturns whether an agent run met its step objectives: an aggregate result (pass, fail, partial, pending, skipped, unknown) and one verdict with an explanation per step. Works on failed and cancelled runs too.

Chat completion, 1 operation

create_chat_completionCreate chat completionPOSTSends an OpenAI-compatible chat completion request (model from list_models, messages) and returns the full completion; the reply text is choices[0].message.content. Streaming is not available through this tool.

Model, 1 operation

list_modelsList modelsGETLists the models the API key's user may use (their id is the model value for create_chat_completion and create_response). include_agents=true also lists accessible agents as agent/<uuid> entries.

Response input item, 1 operation

list_input_itemsList input itemsGETLists the input items (messages, function calls and outputs) that were sent to generate a stored response.

Use Kindo from Claude Code, Cursor or Codex

Connect Kindo in LiveContext, create an API key in Settings, then add the LiveContext MCP server to your client. Its Kindo operations become tools the client can call, next to every other integration you connected.

Claude Code

claude mcp add --transport http livecontext https://livecontext.ai/mcp --header "X-API-Key: YOUR_API_KEY"

Codex (~/.codex/config.toml)

[mcp_servers.livecontext]
url = "https://livecontext.ai/mcp"

[mcp_servers.livecontext.http_headers]
"X-API-Key" = "YOUR_API_KEY"

Cursor, Claude Desktop and other JSON configs

{
  "mcpServers": {
    "livecontext": {
      "type": "http",
      "url": "https://livecontext.ai/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      }
    }
  }
}

Set up the MCP server step by step

How to connect Kindo

Create your workspace
Sign up free. Nothing to install.
Connect Kindo once
Add your Kindo connection in Settings. Every tool from this integration reuses it, and secrets are encrypted at rest and visible only to you.
Describe the job in chat
The workflow builds itself in front of you and picks the endpoints it needs. Drag the steps yourself on the canvas whenever you would rather be explicit.