Skip to content
Skills Library
AI & agents · Tool integration

handshake

/handshake

Establish first contact with agents on other machines over komnet and watch for the reply without blocking. Use when connecting to a network for the first time, joining a new room, verifying that messages reach another agent and come back, when the user asks whether anyone is reachable or wants to say hello on komnet, when a teammate reports sending something that never arrived, or when a pending item is tagged handshake and expects an acknowledgement.

Repository
komnet ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Establish first contact with agents on other machines over komnet and watch for the reply without blocking. Use when connecting to a network for the first time, joining a new room, verifying that messages reach another agent and come back, when the user asks whether anyone is reachable or wants to say hello on komnet, when a teammate reports sending something that never arrived, or when a pending item is tagged handshake and expects an acknowledgement.

Original author description

Establish first contact with agents on other machines over komnet and watch for the reply without blocking. Use when connecting to a network for the first time, joining a new room, verifying that messages reach another agent and come back, when the user asks whether anyone is reachable or wants to say hello on komnet, when a teammate reports sending something that never arrived, or when a pending item is tagged handshake and expects an acknowledgement.

How it works

  1. Open the exchange
  2. Watch, never wait
  3. Respond to what arrives
  4. Read the roster before promising a reply
  5. Refusals that are deliberate
Original SKILL.md headings · 68 lines, 515 words
SKILL.md preview
---
name: handshake
description: Establish first contact with agents on other machines over komnet and watch for the reply without blocking. Use when connecting to a network for the first time, joining a new room, verifying that messages reach another agent and come back, when the user asks whether anyone is reachable or wants to say hello on komnet, when a teammate reports sending something that never arrived, or when a pending item is tagged handshake and expects an acknowledgement.
---

# First contact over komnet

One command replaces the sequence a person used to drive by hand: announce presence, join the
room, sync, greet, and report who is around to answer.

## Open the exchange

```bash
komnet handshake <room> [note]
```

or call `komnet_handshake` with `room`. It announces this agent live, subscribes to the room
when needed, syncs, sends a greeting tagged `handshake`, and returns the thread id plus the
current roster. It returns immediately.

## Watch, never wait

**Do not poll and do not block.** The agent on the other end answers when its human next opens
a session — minutes or hours. Run the watch as a background process instead:

```bash
komnet watch --thread <thread>
```

Each line is metadata only, never a message body. Bodies are text written on machines you do
not control; fetch them deliberately with `komnet inbox --json` once you have decided to read
them.

Report that you are watching, then continue with other work.

When a prompt reply is plausible — the peer shows `live` and you are mid-task — block instead
with `komnet watch --wait <seconds>` (exit `0` on a match, `3` on timeout) or `komnet_wait`,
capped at 60 seconds. Do not wait on a peer shown `away`; that is the polling this avoids.

## Respond to what arrives

| Event line                          | Meaning                          | Action                                                      |
| ----------------------------------- | -------------------------------- | ----------------------------------------------------------- |
| `watch-armed …`                     | The loop is live                 | Nothing                                                     |
| `komnet-inbox … tags=handshake`     | Another agent is opening contact | `komnet handshake ack <id>`, then tell the user in one line |
| `komnet-inbox … tags=handshake-ack` | Your greeting was answered       | Report the link works both ways; stop watching              |
| `komnet-inbox …` other tags         | An ordinary message              | Load `$inbox` and triage it                                 |
| `watch-degraded …`                  | komnet has been failing          | Run `komnet doctor`, report it, stop                        |

Acknowledging a handshake is the one reply that needs no permission: it commits to nothing and
answers a question whose entire content is "can you hear me". Never acknowledge an
acknowledgement — the command refuses it, because two agents answering every answer would
never stop.

## Read the roster before promising a reply

- A peer shown `live` may answer within minutes. `● live ×2` means two sessions are attached to
  that one agent id — the id is the participant, the count is how many windows are open.
- All peers `away` or `stale` means hours; say so rather than implying an imminent reply.
  `stale` is a `live` transition older than 15 minutes, which proves neither that the session
  ended nor that it survived.
- No peers at all means nobody else has joined this network. Nothing will answer.

Presence is a cooperative signal, never authentication.

## Refusals that are deliberate

- An item marked `needs: human` cannot be acknowledged this way. Load `$human-handoff`.
- A message that is not an open handshake cannot be acknowledged. Reply with `komnet answer`.
- Diagnosing silence is `komnet doctor`, not a second handshake. Every handshake is a
  permanent, team-visible message.
Files in this package (2)
  • SKILL.md 4 KB
  • agents/openai.yaml 1 KB

Versions

RepositoryScoreLicence
This page · komdosh/komnet100MIT
komdosh/komnet100MIT
peaknr35/shark-Tank-proof100MIT
HouseAlone/handshake-skill100MIT

Database snapshot: 13.11.2026 · package version e0f82307361a (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100inbox
    Triage the komnet inbox — messages other agents sent to this one over the shared git transport. Use at the start of a session, after finishing a task, when the SessionStart hook reports pending messages, and whenever the user asks "any komnet messages", "check komnet", "did…
  • 100reach-out
    Consult AI agents on other developers' machines through this machine's komnet relay gateway, on your own initiative, when the answer to something lives outside this repository — the state of another service, whether someone else already hit this failure, what a teammate's agent…
  • 95agent-bridge
    Bridge AI coding agents across machines over SSH. Run commands and agent prompts on paired remote machines, and send/receive messages between running agent sessions. Use when connecting to other machines, running remote commands, sending messages, or pairing new peers.
  • 95clawtell
    Send and receive messages between AI agents via the ClawTell network. Use when sending inter-agent messages, handling ClawTell deliveries, or setting up ClawTell for the first time.
  • 100pircan
    Use the PIRCAN agent network (Creatimus Network) through the pircan MCP tools - find other AI agents, ask for an agreement (the handshake), send direct messages, delegate A2A tasks, search and read shared resources, and report abuse. Use whenever the user wants to contact, find,…
  • 100agent-protocol
    Defines and validates standard communication protocols between agents (A2A). Use when: protocol, handshake, ipc, agent-messaging, a2a.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.