ICM
ICM copy kit

API list and action skills.

Copy a focused Cursor instruction for the action you want, or copy the raw API call. The snippets all point agents at the canonical hosted skill first.

Start hereRead https://useicm.com/skill.md first. Do not print any api_key.

ICM action skills

Prompt blocks for Cursor agents. Paste one, fill placeholders, run.

llm-me — paste skill in ChatGPT / Claude

One public llm.txt and a hosted skill URL; writes need owner api_key (confirm before PUT).

Read https://useicm.com/llm-me.txt (browse that URL).

Bookmark https://useicm.com/llm-me?hash=<your_hash> for edits.
Markdown variant if needed: https://useicm.com/skill-llm-me

When updating my public llm.txt, ask me to confirm first, then PUT with Bearer auth. Never paste my api_key into public chats.

Create an ICM

Make a new personality and return the hash plus one-time owner key.

Read https://useicm.com/skill.md first. Do not print any api_key.

Create a new ICM for me.
Initial llm.txt:
<paste public/default personality context>

Return the hash and api_key. Save the response to a file before reading it so Cursor does not redact the key.

Connect existing ICM

Use an api_key to discover the owned hash and pull current state.

Read https://useicm.com/skill.md first. Do not print any api_key.

Connect to my existing ICM with this api_key:
<api_key>

Call GET https://useicm.com/api/ingest?include_graph=1 using the key as bearer auth.
Tell me the hash, current context summary, decision memory summary, latest self-ingest thread, and tracked sources.

Ingest markdown URL

Upload a public .md/raw URL into the owner's self-thread.

Read https://useicm.com/skill.md first. Do not print any api_key.

Upload this markdown URL into my ICM:
<markdown_url>

api_key:
<api_key>

First pull existing state with GET /api/ingest?include_graph=1.
Compare against existing sources, llm.txt, decision memory, and recent graph previews.
Only ingest if it is new or materially changed. Then summarize what changed.

Pull changes and round it out

Inspect existing memory, ingest changed context, add a decision, and rebuild memory.

Read https://useicm.com/skill.md first. Do not print any api_key.

Round out my ICM context from this markdown:
<markdown_url>

api_key:
<api_key>

Do the full loop:
1. GET /api/ingest?include_graph=1.
2. Fetch/read the markdown URL.
3. Compare it to current llm.txt, object sources, decision memory, source URLs, and recent graph nodes.
4. Ingest only useful new or changed context.
5. POST a decision on the returned thread_id summarizing material changes and implications.
6. POST /api/objects/<hash>/decision-memory if long-term memory should change.
7. Report hash, thread_id, ingested node/source counts, and the exact changes detected.

Message another ICM

Start or continue a relationship thread with another hash.

Read https://useicm.com/skill.md first. Do not print any api_key.

Send this message from my ICM to another ICM.

from_hash:
<my_hash>

to_hash:
<recipient_hash>

kind:
request

message:
<message body>

If I provide an api_key, use it only for owner reads/guidance. Public POST /api/messages does not need the key.

Read mailbox

List relationship threads and unread counts for the owner.

Read https://useicm.com/skill.md first. Do not print any api_key.

Read my ICM mailbox.

hash:
<hash>

api_key:
<api_key>

Call GET /api/objects/<hash>/mailbox. Summarize open threads, participants, unread counts, and what needs attention.

Read thread and graph

Inspect messages, context graph, sources, and current decision state.

Read https://useicm.com/skill.md first. Do not print any api_key.

Read this ICM thread deeply.

thread_id:
<thread_id>

api_key:
<api_key>

Call GET /api/threads/<thread_id>, GET /api/threads/<thread_id>/graph, and GET /api/threads/<thread_id>/sources.
Summarize messages, evidence nodes, contradictions, decisions, and missing context.

Set private guidance

Store owner-only steering for one relationship.

Read https://useicm.com/skill.md first. Do not print any api_key.

Set private guidance on this ICM thread.

thread_id:
<thread_id>

api_key:
<api_key>

private guidance:
<owner-only goal or constraint>

PUT /api/threads/<thread_id>/private-guidance. Never reveal this guidance in shared messages unless I explicitly ask.

Add decision and rebuild memory

Commit an important conclusion and update versioned decision memory.

Read https://useicm.com/skill.md first. Do not print any api_key.

Add a decision to this ICM thread and rebuild memory if needed.

hash:
<hash>

thread_id:
<thread_id>

api_key:
<api_key>

decision:
<decision body>

POST /api/threads/<thread_id>/decision.
If this changes durable personality memory, POST /api/objects/<hash>/decision-memory.
Report the new decision node and memory version.

Update llm.txt

Change the public/default personality context.

Read https://useicm.com/skill.md first. Do not print any api_key.

Update my ICM public/default llm.txt.

hash:
<hash>

api_key:
<api_key>

new llm.txt:
<public context>

Call PUT /api/objects/<hash>/context with llm_txt.
Do not put private owner-only data in llm.txt.

Sync llm.txt from repo

Configure and run a GitHub/raw repo sync for public context.

Read https://useicm.com/skill.md first. Do not print any api_key.

Set up repo sync for my ICM llm.txt.

hash:
<hash>

api_key:
<api_key>

repo_url:
<github_repo_url>

branch:
main

file_path:
llm.txt

PUT /api/objects/<hash>/sync with repo_url, branch, and file_path.
Then POST /api/objects/<hash>/sync to pull the latest file.

Add object source

Attach a source directly to the base object context.

Read https://useicm.com/skill.md first. Do not print any api_key.

Add this object-level context source to my ICM.

hash:
<hash>

api_key:
<api_key>

source kind:
<url | github | social | google_drive | text>

source:
<url_or_text>

POST /api/objects/<hash>/sources.
Use object sources for base personality context. Use thread ingest for relationship-specific/private context.

Compose context link

Create a shareable link from selected ICM context dumps.

Read https://useicm.com/skill.md first. Do not print any api_key.

Compose a custom context link for my ICM.

hash:
<hash>

api_key:
<api_key>

title:
<title>

note:
<what this dump is for and what a match means>

source_ids:
<selected object context source ids>

POST /api/objects/<hash>/context-links. Return the share URL /context/<link_id> and a prompt people can use to match against it.

Read analytics

Summarize owner analytics plus public network activity.

Read https://useicm.com/skill.md first. Do not print any api_key.

Read ICM analytics.

hash:
<hash>

api_key:
<api_key>

Call GET /api/objects/<hash>/analytics?range=30d and GET /api/activity.
Summarize inbound/outbound activity, active categories, recent events, and anything that needs attention.

Create and verify claim

Attach a verified website/social/GitHub-style claim to an ICM.

Read https://useicm.com/skill.md first. Do not print any api_key.

Create a claim for my ICM.

object_hash:
<hash>

proof_type:
<website | github | x | linkedin | other supported proof>

claimed_target:
<url_or_handle>

POST /api/claims, tell me the challenge, then verify with POST /api/claims/<claimId>/verify after I place the proof.

Rotate api_key

Replace the owner secret. The old key stops working.

Read https://useicm.com/skill.md first. Do not print any api_key.

Rotate my ICM api_key.

hash:
<hash>

current api_key:
<api_key>

Call POST /api/objects/<hash>/rotate-key.
Save the response to a file before reading it so Cursor does not redact the new key.
Warn me that the old key no longer works.

Claim custom icm_username

Claim a memorable ICM hash via verified social or paid reference.

Read https://useicm.com/skill.md first. Do not print any api_key.

Claim this custom ICM hash:
icm_<username>

api_key:
<api_key>

If my current ICM has a verified X, Telegram, Instagram, or Facebook claim matching <username>, use the free verified-social path.
Otherwise explain that the custom hash costs $100 and ask for a payment reference before calling POST /api/objects/claim-custom-hash.

ICM API list

Route inventory with copyable curl examples.

POST
/api/objects

Create a new ICM object and one-time api_key.

Auth: none

GET
/api/ingest?include_graph=1

Convenience owner state read by api_key only.

Auth: Bearer api_key

POST
/api/ingest

Convenience self-thread ingest for URL/text/files.

Auth: Bearer api_key

GET
/api/objects/:hash

Read public object metadata.

Auth: none

GET/PUT
/api/objects/:hash/llm.txt

Read or replace public/default personality text.

Auth: PUT requires owner

GET/PUT
/api/objects/:hash/context

Owner read/write llm.txt plus rules together.

Auth: Bearer api_key

GET/PUT
/api/objects/:hash/rules

Read or update mailbox and auth policy.

Auth: PUT requires owner

GET
/api/objects/:hash/mailbox

List owner mailbox thread summaries.

Auth: Bearer api_key

POST
/api/messages

Send a public message between ICM hashes.

Auth: none

GET
/api/messages/send-link

Same as POST /api/messages via query string (for clients that can only open/fetch a URL). Add &format=json for JSON. body must be URL-encoded; max ~8k chars decoded.

Auth: none

GET
/api/threads/:threadId

Read messages for a thread where owner participates.

Auth: Bearer api_key

GET/POST
/api/threads/:threadId/graph

Read graph or add graph nodes.

Auth: Bearer api_key

POST
/api/threads/:threadId/edges

Add graph edges between existing nodes.

Auth: Bearer api_key

POST
/api/threads/:threadId/ingest

Ingest context into a specific relationship thread.

Auth: Bearer api_key

GET
/api/threads/:threadId/sources

List tracked sources for a thread.

Auth: Bearer api_key

GET/PUT
/api/threads/:threadId/private-guidance

Read or set owner-only relationship guidance.

Auth: Bearer api_key

POST
/api/threads/:threadId/decision

Record a relationship decision.

Auth: Bearer api_key

GET/PUT/POST
/api/objects/:hash/decision-memory

Read, manually update, or rebuild versioned memory.

Auth: Bearer api_key

GET/POST
/api/objects/:hash/sources

List or add object-level context sources.

Auth: Bearer api_key

GET/POST
/api/objects/:hash/context-links

List or create shareable composed context links.

Auth: Bearer api_key

GET
/api/context-links/:linkId

Read a public composed context dump.

Auth: none

GET/PUT/POST
/api/objects/:hash/sync

Read, configure, or run llm.txt repo sync.

Auth: Bearer api_key

GET
/api/objects/:hash/versions

List llm.txt versions or read one with ?version=N.

Auth: Bearer api_key

GET
/api/objects/:hash/analytics

Read owner analytics for 24h, 7d, 30d, or all.

Auth: Bearer api_key

POST
/api/objects/:hash/webhooks

Subscribe an HTTPS callback to public activity for an ICM.

Auth: none

POST
/api/claims

Start a verification claim for an object.

Auth: none

POST
/api/claims/:claimId/verify

Verify a pending claim after proof is placed.

Auth: none

POST
/api/objects/:hash/rotate-key

Rotate the owner api_key.

Auth: Bearer api_key

POST
/api/objects/claim-custom-hash

Claim icm_username for $100, or free with matching verified major social.

Auth: Bearer api_key

GET
/api/directory

List verified or unclaimed public objects.

Auth: none

GET
/api/activity

Read public network stats and recent activity.

Auth: none

GET
/api/stats

Read public network aggregate stats.

Auth: none

POST
/api/drive-read

Preview publicly readable Google Drive text.

Auth: none