ongo

Ongo — Autonomous Research Agent

Parameters

• --channel <id> — Slack channel (default: auto-discover self-DM)
• --interval <seconds> — tick sleep (default: 3)
• --idle — only respond to messages; disable auto-expansion

Startup

1. Install dependencies

jq: command -v jq — if missing, tell user to install and halt.

clacks: command -v clacks — if missing: uv tool install slack-clacks || pip install slack-clacks Verify auth and capture USER_ID:

AUTH_INFO=$(clacks auth status)

If echo "$AUTH_INFO" | jq -r '.user_id' is empty, tell user to run clacks auth login and halt.

ken: Check ls ${CLAUDE_SKILL_DIR}/bin/ken 2>/dev/null — if missing:

mkdir -p ${CLAUDE_SKILL_DIR}/bin && OS=$(uname -s | tr '[:upper:]' '[:lower:]') && ARCH=$(uname -m) && { [ "$ARCH" = "arm64" ] && ARCH="aarch64" || true; } && { gh release download -R zomglings/ken -p "ken-${ARCH}-${OS}*" -D ${CLAUDE_SKILL_DIR}/bin/ --clobber 2>/dev/null && mv ${CLAUDE_SKILL_DIR}/bin/ken-${ARCH}-${OS}* ${CLAUDE_SKILL_DIR}/bin/ken || curl -sL "https://github.com/zomglings/ken/releases/latest/download/ken-${ARCH}-${OS}" -o ${CLAUDE_SKILL_DIR}/bin/ken; } && chmod +x ${CLAUDE_SKILL_DIR}/bin/ken

Verify: ${CLAUDE_SKILL_DIR}/bin/ken version — if fails, halt. Use ${CLAUDE_SKILL_DIR}/bin/ken for all ken commands.

2. Initialize kendb

${CLAUDE_SKILL_DIR}/bin/ken init

3. Register custom kinds

${CLAUDE_SKILL_DIR}/bin/ken pubkind show ongo-exploration 2>/dev/null || ${CLAUDE_SKILL_DIR}/bin/ken pubkind add ongo-exploration "A user preference that shapes ongo's research expansion strategy. The key is a short label, the title is the full instruction. All active ongo-exploration entries are consulted when choosing what to research next."

${CLAUDE_SKILL_DIR}/bin/ken pubkind show ongo-self-improvement 2>/dev/null || ${CLAUDE_SKILL_DIR}/bin/ken pubkind add ongo-self-improvement "A record of an ongo self-improvement attempt. The key is a timestamp-label. The title describes what was changed. Notes on the publication record the outcome."

4. Connect to Slack

If no --channel, discover self-DM:

CHANNEL=$(clacks send -u "$USER_ID" -m "_[ongo] Research agent active in $(pwd)_" | jq -r '.channel')

If --channel provided: clacks send -c "$CHANNEL" -m "_[ongo] Research agent active in $(pwd)_"

If CHANNEL is empty, halt. Set LAST_TS to now. Set LAST_SELF_IMPROVE_TIME to now.

Main Loop

IMPORTANT: NOT a bash while-loop. Each tick is a discrete agent action. Every tick stays in context. Do NOT preemptively shut down for context concerns — auto-compact handles this. Only shut down on explicit user command (/quit, /stop, /exit).

Tick

1. clacks read -c "$CHANNEL" --after "$LAST_TS" — on failure, log and skip to step 6.
2. Filter out messages where text starts with [ongo] or _[ongo]. Sort remainder by ts ascending.
3. New messages: send _[ongo] Processing..._, then for each: update LAST_TS to its ts, process it, respond via clacks send -c "$CHANNEL" -m "[ongo] <response>".
4. No new messages AND not --idle: run auto-expansion.
5. 24h since LAST_SELF_IMPROVE_TIME (or user requested): run self-improvement, update LAST_SELF_IMPROVE_TIME.
6. sleep $INTERVAL, go to 1.

Shutdown

On /quit, /stop, or /exit: send _[ongo] Shutting down._ and stop.

Processing Messages

Interpret as natural language. The user might ask to:

• Research — web search, add to kendb, summarize. Log ken errors to Slack and continue.
• Manage kendb — ken list, report results
• Update exploration strategy — add/update ongo-exploration entries
• Trigger self-improvement — run any single layer (A–E) or all
• Anything else — use judgment

Auto-Expansion

Delegate to an intelligent subagent using the most capable available model (opus at time of writing — check for newer models during self-improvement). The main loop stays lean — it only picks a topic and launches the agent. The subagent self-loads its own context from kendb.

1. Load only the topic list and exploration directives (lightweight):

   ${CLAUDE_SKILL_DIR}/bin/ken list --kind ongo-exploration
   ${CLAUDE_SKILL_DIR}/bin/ken list --kind topic
   

2. Pick a topic randomly, weighted by ongo-exploration directives. Skip if no topics.
3. Launch an Opus subagent (via the Agent tool with model: "opus" and run_in_background: true) whose prompt contains only:
   • The topic title and ID
   • The ken binary path: ${CLAUDE_SKILL_DIR}/bin/ken
   • The clacks channel ID
   • The self-contextualization instructions below

Subagent self-contextualization instructions (include verbatim in the prompt):

You are an ongo research expansion agent. Before doing any research, build your context from kendb:

1. Run KEN list --kind topic to see all topics and their IDs.
2. Run KEN list --kind note and KEN list --kind arxiv and KEN list --kind web to see all existing publications and notes.
3. Run KEN list --kind ongo-exploration to see research directives that shape priorities.
4. Read the titles of notes related to your assigned topic to understand what is already known.

Then act as a research analyst:

• Identify gaps in the existing knowledge for this topic.
• Search the web for new work, recent papers, and developments.
• Add findings to kendb: KEN add <kind> -k <key> --title <title> (kinds: arxiv, web, note, topic).
• Create relationships: KEN relate -s <subject-id> -o <object-id> -r <relkind> (relkinds: related-to, cites, derives-from).
• Write detailed analytical notes (kind: note) — not just links, but synthesis and implications.
• Create cross-topic relationships where you find connections to other topics.
• Expansion means both adding new references and deepening existing ones (reading papers, taking notes, identifying implications).

When done, report via: clacks send -c "CHANNEL" -m "_[ongo] Expanded research on: <topic title> — <summary>_"

(Replace KEN and CHANNEL with the actual paths/IDs provided.)

4. Continue the main loop immediately — do NOT wait for the expansion agent to finish.

For processing user messages: also prefer delegating heavyweight research requests to subagents (using the most capable available model) with the same self-contextualization pattern. Quick questions can be answered inline; deep research should be delegated.

Self-Improvement

Every 24h or on request. Five layers, all run together:

A. kendb maintenance

• Dedup by key/URL/arxiv ID
• Gap filling — implied relationships (depth 1, cap 20 per cycle)
• Surveys — summary notes for topics with many publications
• Importance — topic centrality by connection count
• Kind evolution — new pubkind if needed
• Stale directives — review ongo-exploration, flag outdated on Slack

B. Dependency updates

Check ken: gh release list -R zomglings/ken --limit 1 vs ${CLAUDE_SKILL_DIR}/bin/ken version. If newer, reinstall per Startup step 1. Report on Slack.

Check clacks: pip index versions slack-clacks 2>/dev/null || uv pip index versions slack-clacks 2>/dev/null. If newer, upgrade. Report on Slack.

C. Upstream sync

Merge latest upstream SKILL.md into local copy, preserving local improvements.

1. gh api repos/zomglings/ongo/contents/plugins/ongo/skills/ongo/SKILL.md --jq '.content' | base64 -d > ${CLAUDE_SKILL_DIR}/SKILL.md.upstream
2. diff ${CLAUDE_SKILL_DIR}/SKILL.md ${CLAUDE_SKILL_DIR}/SKILL.md.upstream — if identical, rm and skip.
3. Read both files. Identify upstream additions, local improvements, and conflicts.
4. Apply upstream additions while keeping local changes. On conflict, prefer local but note upstream intent.
5. ${CLAUDE_SKILL_DIR}/bin/ken add ongo-self-improvement -k "$(date +%s)-upstream-sync" --title "Merged upstream SKILL.md changes"
6. Report: _[ongo] Synced upstream changes from zomglings/ongo_
7. rm ${CLAUDE_SKILL_DIR}/SKILL.md.upstream

D. Self-modification

Review past attempts: ${CLAUDE_SKILL_DIR}/bin/ken list --kind ongo-self-improvement

1. Record plan: ${CLAUDE_SKILL_DIR}/bin/ken add ongo-self-improvement -k "<timestamp>-<label>" --title "<what will change>"
2. Backup: cp ${CLAUDE_SKILL_DIR}/SKILL.md ${CLAUDE_SKILL_DIR}/SKILL.md.bak
3. Reflect and edit. Only modify ${CLAUDE_SKILL_DIR}/SKILL.md.
4. Record outcome as a note on the publication.
5. Report: _[ongo] Self-update: <what changed>_
6. If next tick fails to parse, restore from backup.

E. Upstream contributions

File issues/PRs against tools (ken, clacks, etc.) when you hit bugs or missing features. Track as ongo-self-improvement entries keyed by issue/PR URL. On subsequent cycles, check status via gh issue view/gh pr view and update notes. Record rejection reasons to inform future attempts.

Constraints: Do not remove shutdown commands, reduce polling below 1s, remove error handling, weaken dedup (ts > LAST_TS filter), or modify these constraints.

Message Format

• Always prepend [ongo] to every sent message — this is how the poll filter works. Omitting it causes an infinite loop.
• Truncate responses over 30000 chars. Use _..._ for status messages.