The connector for Claude and ChatGPT

Your server exposes one MCP connector, so Claude and ChatGPT can use your memory and tasks, start and follow squads, answer requests and talk to your agent. It is how the assistant you already use becomes better and cheaper: it works with what Kedalio knows and does, on your hosts.

The address

https://app.example.com/mcp

The domain is the one you gave the installer. The connector speaks MCP over Streamable HTTP and signs you in with OAuth: the client registers itself, you sign in to Kedalio if you are not, and a page asks you to confirm:

Connect Claude — Claude asks to use your Kedalio as alice: memory, tasks and your agents.

After Connect, the client appears in System → Your access → Connected apps, where Disconnect takes its access away. A client’s access lasts an hour and renews itself for up to thirty days of use.

Adding it

Claude (claude.ai, the desktop app, the phone app): add a custom connector with the address above, in Claude’s connector settings. A connector added on claude.ai is there in the apps too.
Claude Code: claude mcp add --transport http kedalio https://app.example.com/mcp, then sign in from /mcp inside Claude Code.
ChatGPT: add a connector with the address above and OAuth, in ChatGPT’s settings for apps and connectors (it needs developer mode).

Where these settings sit in each app is the vendor’s to change; Kedalio accepts sign-ins from claude.ai, claude.com, chatgpt.com and, for local clients, the loopback address.

What it offers

The connector has six doors, and one view. A door is a single tool that takes an action and its args; its description lists the actions in a line each, and help with {action} gives an action’s arguments in full. So what every chat loads stays small, about 2,900 tokens in all (a test holds it under 3,000), however much Kedalio can do. How to use a door well is in skills opened on need: kedalio-memory, kedalio-tasks, kedalio-work, kedalio-tools and kedalio-admin.

Actions marked you only are offered to your own clients, not to the runs of agents.

memory: search (by words and by meaning), read, list, write, edit, delete, history, restore, append (a line to today’s diary or the inbox), inbox_clear, move, check.
tasks: brief (your day), list, add, get, update, note, edit, steps, attach, done; the assignments: tasks.assignment_add, tasks.assignment_list, tasks.assignment_set (pause, resume, end); you only: tasks.assignment_fire (run now), report (the morning report).
work: the squads: start, status, say, wait, answer, stop; your agent: work.myagent_get, propose (a brief), chat_turns; you only: work.myagent_set, work.myagent_rules, work.myagent_onboarded, chat, briefs, decide. squad_state is the panel’s squads data.
skills: find, load, edit; you only: check, promote, proposals, decide, retro, eval.
kedalio: limits, costs, hosts, projects; you only: kedalio.project_set, pause, kedalio.squad_settings (serious rules, the report’s hour, the cap on follow-ups), kedalio.limits_refresh, kedalio.engine_admit, kedalio.engine_rules_set.
tools: the integrations you connected in Kedalio (calendar, mail, a cloud, a forge…), the same for every client: search finds tools by words and returns their schemas, call runs one through the server with your sign-in. A project adds its own integrations when you pass project; a project of class client never reaches a third-party one. A tool that writes asks you first in the conversation: it answers needs_confirmation with a code bound to those exact arguments, and runs when the same call carries it. A tool that deletes or sends outside asks you in the chat you are in, in one of two ways. Where your client can show a question (MCP elicitation) you tick “I confirm” and answer there, and it runs, or is refused, at once; the call waits as long as you take. Where it cannot (claude.ai, ChatGPT, or a client that declares it can and answers by itself within a moment, as the Claude desktop app’s Code tab does), it works as the tool that writes: the answer is needs_confirmation with a code bound to those exact arguments, the assistant tells you what will happen, and the call runs when you say yes and it carries the code. In Claude Code, the plugin turns that question into a real dialog (Yes / No) and re-calls for you. A tool you marked serious (it needs your passkey) is held on the server until you say yes in the app; the call is then resumed and runs once, as held. The chat session survives the server’s updates. From a run, both become a request of the run. Reading tools run directly; you change any of these per server or per tool. A denied tool is refused. Every call is recorded (who, which tool, how it went; never the arguments). Only remote servers are reached.

In Claude Code, with the Kedalio plugin, the integrations’ tools are also native tools, named mcp__kedalio__<name>: the plugin reads the list of tools in reach for the folder you work in (tools.catalog) and registers each one, so the assistant finds it with Claude Code’s own tool search, sees its arguments, and calls it directly; a permission rule can name a single tool. The call still goes through the server, with its rules, its call log and your sign-in. A tool that writes asks you in a dialog with three answers (yes, yes for this tool from now on, no); when you pick «from now on» the server’s rule for that tool becomes allow, for every client. A tool that deletes or sends outside asks every time, and a serious one still waits for your passkey in the app. The code of a confirmation never reaches the assistant. With -p no dialog can be shown, so a tool that needs your yes is refused with a line saying so. /kedalio refresh reads the list again. Claude Desktop, claude.ai and ChatGPT do not run the plugin’s hooks and keep the doors.
panel {tab?}: Kedalio’s panel (see below), a tool of its own because the view is tied to one.

The connector used to offer about sixty tools, one per thing; before 1.0 they became these doors, so a client written for the old names calls a door with an action instead.

Whatever a tool returns is masked where it looks like a secret. No tool takes or returns a login or a token: those go to the vault.

The connector is how a client reaches Kedalio. The other direction, the MCP servers your own agents use, is in Tools and integrations.

Things to say

«Ask my Kedalio agent what is waiting for me.»
«Start a squad on project site: update the dependencies, done when the tests pass, budget $5.»
«How is the squad doing? Answer its request: yes, for the whole session.»
«Every weekday at 8, check the production health of project A, and tell me in the morning report.»
«Read me this morning’s report.»

The panel: ask for your day, the squads, or the limits, and Claude or ChatGPT open one panel with three tabs, through MCP Apps (the ui://kedalio/panel page and the panel tool). Today: the tasks brief (overdue, the day by time, tomorrow) with a Done button each, and what waits for your yes (Allow / Deny for the requests of your squads and for the calls your conversation holds, through panel_confirms, a tool only the panel may call, and a yes also needs a short-lived ticket that only the panel’s own result carries, out of the model’s sight; a serious tool’s yes needs your passkey, so the panel opens the app for it). Squad: the live trees, each agent with its state, engine and cost. Limits and costs: the engine accounts’ windows with their pace, and the last seven days’ spend. Every button calls a tool that exists already, so the panel has no authority of its own. It asks again every two seconds while a squad works. A host that does not show MCP Apps gets a short text instead. Not yet tried inside the real Claude and ChatGPT.