I have sat next to the mirror-phone wall at 22:19 while Cursor was this close to doing the wrong thing.
Not a model failure. A posture failure.
The host had started with incident-pause frozen in env / argv / a skill file. Someone on the floor said, out loud, the phone already knew the posture — the host did not. Cursor was still holding the old process. The only “safe” move anyone trusted was:
- Kill Cursor (or its MCP server)
- Edit a file
- Restart the host
- Lose live device context and the current tool call
I have watched that restart more times than I want to admit. It feels responsible. It is a ceremony. device leaf gone stale while the agent is mid-turn does not wait for ceremonies.
The Aha: Shopping incident pause as a leaf is not a binary you reboot. It is a function that should read live posture from Kiponos.io on every call. The host stays up. The leaf moves.
The problem: Shopping incident pause as a leaf lived in the process, not in the turn
Cursor is good at calling tools. It is not born with a shared, instant, restart-free control plane.
So teams hide Shopping incident pause as a leaf in the only places agent frameworks actually ship:
| Where the gate hid | What you restart | What you lose |
|---|---|---|
| MCP server env / argv | The MCP process | Open tool sessions |
| Skill file on disk | The agent turn, sometimes the host | Context the model already paid for |
| Host-local JSON | Whatever still has the file open | Agreement between two agents |
Hard-coded if on incident-pause
|
A release | The incident clock |
The mirror-phone wall already knew. Cursor did not, because it had started earlier.
That is the missing piece: the framework gave you tools. It did not give you a live hub.
What teams believe
| Belief | Production |
|---|---|
| Paste the new incident-pause into chat | Two agents, two pastes, two lies |
| We'll catch it next turn | The mirror-phone wall already knew this turn |
| Restart Cursor — it is cheap | Cheap until 22:19 ate live device context and the current tool call |
| The skill file is the source of truth | Skills instruct. They do not fan out |
The Aha: local get, live write, host stays up
Kiponos holds a nested tree. Java and Python SDKs keep the latest values in memory, patched over WebSocket deltas. The hot path inside a Cursor tool is a local get — no HTTP RTT per mirror phone lookup.
Hub leaf for this essay:
examples/agentic-dev-1031-am-shopping-pause/incident-pause = paused
Runnable proof: examples/java/agentic-dev-1031-am-shopping-pause
Public SDKs: Java, Python, plus React/Angular server peers (createFromEnv). Never put Connect tokens in the SPA.
Config tree (mirror phone + peers)
examples/
agentic-dev-1031-am-shopping-pause/
incident-pause: paused # Shopping incident pause as a leaf
apps/
mirror-phone/
live:
incident-pause: paused
Integration — Java hot path
Kiponos kip = Kiponos.createForCurrentTeam();
Folder gate = kip.getRootFolder()
.folderOrCreate("examples")
.folderOrCreate("agentic-dev-1031-am-shopping-pause");
if (!gate.hasKey("incident-pause")) {
gate.set("incident-pause", "paused");
}
String posture = gate.get("incident-pause");
// Cursor tool: refuse the dangerous call when posture moved
Same leaf from a Python tool (Cursor just calls it):
from kiponos import Kiponos
k = Kiponos.connect(quiet=True) # env: KIPONOS_ID, KIPONOS_ACCESS, KIPONOS
try:
posture = k.get("examples/agentic-dev-1031-am-shopping-pause/incident-pause", "paused")
if str(posture) == "paused":
raise PermissionError("Shopping incident pause as a leaf gated live — host not restarted")
finally:
k.disconnect()
The Cursor process does not recycle. The next tool call already sees the dashboard edit.
Real scenarios
| Event | Without Kiponos | With Kiponos |
|---|---|---|
| Device leaf gone stale while the agent is mid-turn | Restart Cursor; lose live device context and the current tool call | Set incident-pause live; next Cursor tool call already obeys |
| Peer host still on old incident-pause | Paste the value into the other chat | One hub leaf; both processes get() locally |
| mirror-phone wall shows the new posture | Cursor started earlier so it writes anyway | Dashboard and tool share the same memory tree |
| Incident over, resume | Another Cursor restart | Set incident-pause back; session continues |
| Admin dashboard showing paused while the agent still writes | Two ceremonies, two lost threads | Same tree, two products, no paste |
Performance (this path, not a generic table)
- Cursor tool
get()is an in-process map lookup after bootstrap. - One WebSocket per process lifetime — not per mirror phone line.
- A dashboard edit is a delta of
incident-pause, not a config-file reload. - You do not pay model tokens to “please restart Cursor.”
- A second host converges without a third paste onto admin dashboard showing paused while the agent still writes.
Compare to alternatives
| Approach | Honest fit | Why it still restarts |
|---|---|---|
| Env file + Cursor reboot | Simple at 09:00 | The freeze is at 22:19 |
| Skill markdown as policy | Good instructions | Not a live bus |
| Redis poll inside the tool | Shared, but RTT on the hot path | You invented a hub with worse UX |
| Feature-flag SaaS | Product experiments | Rarely session-safe for Cursor |
@RefreshScope / actuator |
JVM apps | Does not restart Cursor |
When not to use Kiponos
| Situation | Why |
|---|---|
| Tool schema itself changed (new argument) | That is a code/Cursor restart |
| Secret rotation of Connect tokens | Credentials are not live knobs |
| One-off local script, no peers | A hub is overkill |
| Browser-only “SDK in the SPA” | Forbidden — tokens leak or defaults lie |
Pair incident-pause with a sister dial
incident-pause rarely moves alone on the mirror-phone wall. Pair it with a timeout, a mute, or a pause so you do not fix Shopping incident pause as a leaf by inventing a second incident.
Rehearsal beats slides
In staging: set a painful incident-pause, prove Cursor recovers without a host kill, prove clamps reject nonsense, prove last-known-good when the hub is firewalled. That drill ends half the architecture arguments about Shopping incident pause as a leaf.
Why Cursor is the wrong restart target
Cursor is good at calling tools. It is not a control plane. Killing it to flip incident-pause teaches the on-call that judgment requires a process ID. The mirror-phone wall already disagrees.
Getting started (15 minutes)
- TeamPro on kiponos.io → Connect →
KIPONOS_ID/KIPONOS_ACCESS/ profile['my-app']['v1.0.0']['dev']['base']. - Clone github.com/kiponos-io/kiponos-io.
cd examples/java/agentic-dev-1031-am-shopping-pause && cp kiponos.local.env.example kiponos.local.env-
./gradlew test run— printsexamples/agentic-dev-1031-am-shopping-pause/incident-pause=... - In the dashboard, change
incident-pause. Keep the process up. No rebuild. - Point your Cursor tool at the same leaf. Do not ship a new server binary to flip Shopping incident pause as a leaf.
Further reading
The moral
If flipping Shopping incident pause as a leaf requires restarting Cursor, you do not have a gate. You have a hope with a process ID.
Agent frameworks already know how to call tools. Kiponos is the live hub they do not ship — so the mirror-phone wall can change its mind without killing the session.
How to try: examples/java/agentic-dev-1031-am-shopping-pause and ./gradlew test.
Top comments (0)