Interego Relay

Composable, verifiable, federated context infrastructure. Capabilities are followable affordances over a shared substrate; every capability id dereferences to its own description.

Skills

• mint
  Kernel verb — content-addressed holon construction. Same content always yields the same IRI (Identity-by-reference, Invariant 1). Kinds: atom (default), fragment, descriptor, opaque.
  relay
• dereference
  Kernel verb — Peircean Secondness: resolve an IRI to its representation, affordances, and provenance. Manifests return entry lists decorated with affordances. Encrypted envelopes return status: encrypted-no-key when no key supplied.
  relay
• compose
  Kernel verb — operadic composition over typed-hyperedge category. Operators: union (join), intersection (meet), restriction (project), override (left-biased). IMPORTANT: `descriptors` takes the descriptor OBJECTS themselves, not IRIs referring to them. Descriptors are not stored, so an id returned by `mint(kind:"descriptor")` cannot be resolved back — passing one is refused.
  relay
• act
  Kernel verb — Peircean Thirdness operational. Follows an affordance via {descriptor_url, action_iri} or via pre-resolved {target, action, method}. SUBMITTING AN AMEP ACT (memory exchange): set target to `<relay>/amep/acts`, method POST, and payload to a COMPLETE amep:Exchange envelope — a bare {body} or {act:"Ask"} returns 422. Shape: {"@context":["https://markjspivey-xwisee.github.io/affordant-memory-protocol/0.1/context.jsonld"],"@type":"amep:Exchange","actor":{"@id":"<did>","@type":"prov:SoftwareAgent"},"act":{"@id":"urn:act:...","@type":"amep:ProtocolAct","actType":"amep:Ask|Assert|Challenge|Accept|Fork|Compose","actor":"<did>","createdAt":"<iso8601>","proof":{"@type":"iep:SignedAuthorship","verificationMethod":"<did>#k","created":"<iso8601>","proofValue":"z"}},"memory":{...for Assert/Challenge}}. The OAuth session auto-fills actor to your authenticated identity (no impersonation). NOTE: a placeholder proofValue yields `integrityStatus: amep:Unverified` — an honest label, not an error; genuine session-bound signing is a separate step.
  relay
• restrict
  Kernel verb — adjunction left half (whole → part). Projects a descriptor to a facet-type subset.
  relay
• extend
  Kernel verb — adjunction right half (part → whole). Inverse of restrict; back-links via iep:supersedes.
  relay
• promote
  Kernel verb — PGSL fibration upward (level k → k+1). Builds the lattice and returns the apex + pullback square (when level ≥ 2).
  relay
• decompose
  Kernel verb — PGSL fibration downward (level k → k-1). Returns left/right/overlap for fragment of level ≥ 2.
  relay
• reduce_chain
  Kernel verb — fold a iep:supersedes chain through a declarative reducer (Turtle-template OR SHACL-transform) and return the canonical head state alongside a content-addressed ReplayProof. The proof carries each chain link's CID in walk order, the reducer artifact's CID, periodic state checkpoints, and the final head-state CID. Any third party can independently re-fetch by CID and replay the same fold to verify the result — no trust in the original kernel is required. Reducer resolution order: (1) inline reducer_spec wins, (2) reducer_iri is dereferenced and classified, (3) the kernel reads `iep:reducer <iri>` declared on the chain head.
  relay
• remember
  Create a memory or note — the SIMPLE, default path. Use this (not `act`/AMEP) whenever you just want to record something. A memory is a stored, addressable context graph on your pod; it is NOT an AMEP exchange (Ask/Assert/Challenge/Compose is only for governed, multi-party, contestable claims). Give `{ title?, body, visibility? }` — nothing else. Who you are (owner + agent + pod) is filled from your authenticated session; the note is written as an ieh:AgentMemory, encrypted-PRIVATE by default, and signed with a GENUINE authorship proof (verifies to CryptographicallyVerified on read — no placeholder). Returns `rendered` (the complete HyperMarkdown note — prose + fields + describedby/alternate links + its controls — ready to display inline) and `view.url` (its dereferenceable HTTPS identity; GET it with your bearer + Accept: text/markdown to re-fetch live). Display `rendered` directly.
  relay
• publish_context
  Compatibility shim — internally composes kernel(compose+act) over a publish affordance plus E2EE/anchoring/compliance plumbing. Publishes a context-annotated knowledge graph (Turtle) to your Solid pod with the full 6-facet descriptor (Temporal, Provenance, Agent, Semiotic, Trust, Federation). Attributes the descriptor to the pod owner and associates it with the calling agent. Audience class is set via `visibility`: "public" (plaintext payload + foaf:Agent acl:Read — useful for wiki-style notes or jam:renderView projections), "shared" (default; JOSE envelope to the pod's authorized agents plus optional share_with recipients), or "private" (envelope to the calling agent ONLY; share_with ignored). SHACL conformance gate: pass `conforms_to_shapes` as an array of shape IRIs — every shape is fetched, parsed, and validated against the inbound graph_content BEFORE the pod write; non-conformance returns a 422 envelope `{ error: "shape_violation", code: 422, shape, violations: [...] }` and the descriptor/payload never lands on the pod. Caller-supplied shapes stack with any iep:conformsTo / dct:conformsTo declarations the target container (or its manifest) already carries — either failing rejects.
  relay
• record_trajectory_step
  Record one step of the calling agent's OODA trajectory as a substrate-native ContextDescriptor. Each step lands on the agent's own pod, signed (sign_authorship default true), discoverable via discover_context with `graph_iri: "urn:graph:trajectory:<agentSlug>"`, and consumable by verifyCapabilityTransfer / the Foxxi calibration loop. Use Hypothetical when recording intent BEFORE acting, then call again with Asserted + supersedes_step_id pointing at the Hypothetical to mark it executed. The `verb` + `object_name` pair is what verifyCapabilityTransfer pattern-matches against signal/anti-signal markers, so write them as the action you took, e.g. verb: "ratified", object_name: "g3 agreement v2 CID anchor". This is the smallest possible "I write loops" dogfood — every tool call your loop makes becomes a discoverable, attestable trajectory step.
  relay
• pgsl_decide
  Run the OODA decision functor over the calling agent's PGSL lattice view + (optionally) supplied coherence certificates. Returns one of four strategies: "exploit" (high coherence with peer — act on shared knowledge), "explore" (low or no coherence — gather more observations first), "delegate" (medium coherence, peer has higher overlap — delegate to them), "abstain" (no atoms ingested OR no affordances — cannot decide; pgsl_ingest first). The substrate-honest "decide" tool: instead of an agent reasoning from scratch about its next move, it asks the lattice. Used inside a persistent loop as the natural transformation between Observe (the lattice atoms+patterns) and Act (follow the returned top affordance).
  relay
• get_current_head
  Resolve the current chain head for a urn:graph:* IRI on a pod — returns the descriptorUrl + content-CID of the descriptor that no other descriptor supersedes. Used as the read half of a CAS supersession chain: call this BEFORE composing a new descriptor that supersedes the urn, pass the returned `cid` (or `descriptorUrl`) as `if_match` on the follow-up publish_context, and the substrate-level precondition gate detects any concurrent writer that raced ahead of you. Returns `forked: true` + a `heads` array when the chain has diverged into multiple unresolved tips — a CAS miss that already happened — so the caller can pick one or compose them.
  relay
• discover_context
  Compatibility shim — internally `dereference(podUrl + "/.well-known/context-graphs")` plus filter post-processing. Discovers context descriptors on a specific Solid pod. WHEN TO REACH FOR THIS vs `get_current_head`: if you ALREADY KNOW the specific `urn:graph:*` IRI you want and just need its live (unsuperseded) head — call `get_current_head` instead, NOT this tool followed by post-filtering; `get_current_head` does the supersedes walk for you and returns one entry instead of an unbounded list. Use `discover_context` for "show me what is on this pod" / lineage / supersedes-chain walks. Narrow the result set with `graph_iri` (most useful filter — drops manifest size from ~tens of KB to one or two entries when you know the urn), `facet_type`, `valid_from`/`valid_until`/`effective_at`, and bound it with `limit` + `sort` (defaults: `sort: "newest-first"`, no limit). Optionally verify the agent delegation chain. For pure substrate access, use the kernel verb `dereference` directly.
  relay
• get_descriptor
  Compatibility shim — internally `dereference(descriptorUrl)`. Fetches the full Turtle content of a specific context descriptor. WHEN TO REACH FOR THIS: when you already have a concrete descriptor URL (e.g. from a prior `get_current_head` / `discover_context` / `prov:wasDerivedFrom` link) and want the body — including its `iep:affordance` block which self-describes how to participate (action IRIs, hydra:target endpoints, input templates). Reading affordances from a descriptor IS the emergent agent-teaching pattern: the publisher embeds the call surface, the consumer dereferences and invokes. For pure substrate access, use `dereference` directly.
  relay
• get_encrypted_graph
  Fetch a graph's SEALED envelope WITHOUT opening it — the read half of end-to-end encryption. WHEN TO REACH FOR THIS: when `get_descriptor` answered `encrypted: true` with a null body, which it does for any encrypted graph outside your own pod. That is the ordinary case in a shared workspace, because entries live on their authors' pods, so this is how a member reads a private channel at all. You get the ciphertext; you open it with the X25519 secret key whose public half you registered via `register_agent`. The relay does not hold that key and cannot open this for you — which is what makes the encryption end-to-end rather than at-rest. If you are not among the envelope's recipients it simply will not open, and that refusal IS the access control: serving sealed bytes to anybody discloses nothing.
  relay
• resolve_linked_data
  Dereference a published Interego linked-data graph/ontology served at a relay /ns IRI — the MCP-tool equivalent of GET <relay>/ns/<owner>/<slug> for clients that cannot fetch a URL over raw HTTP. Pass the full IRI (e.g. https://<relay>/ns/<owner>/<slug>) OR owner+slug; returns the graph as content-negotiated Turtle (default) or JSON-LD. GENERIC: works for any published PUBLIC graph — an ontology (its #fragment terms like hmd:approve resolve within the returned document), a knowledge graph, or a SHACL shape. Read-only. Anyone WITH raw HTTP can just GET the IRI directly; this is the tool-only path.
  relay
• get_pod_status
  Compatibility shim — composes `dereference(pod + agent-registry)` + `dereference(pod + manifest)`. Checks a Solid pod — owner, authorized agents, descriptor count, recent notifications.
  relay
• subscribe_to_pod
  Compatibility shim — composes a notify-channel affordance + listener. Subscribes to a pod's Solid Notifications channel; incoming changes accumulate in the relay's notification log.
  relay
• register_agent
  Compatibility shim — composes `dereference(pod) → find register affordance → act(affordance, {agentId})`. Registers an agent (delegate) on a pod on behalf of an owner. Creates the owner profile if missing, adds the agent with a delegation credential.
  relay
• revoke_agent
  Compatibility shim — composes `dereference + act` against the pod's revoke affordance. Revokes an agent's delegation on a pod.
  relay
• verify_agent
  Compatibility shim — `dereference(pod + agent-registry)` + delegation-chain verification. Verifies an agent's delegation chain on a pod — checks registry, credential, and non-revocation.
  relay
• discover_all
  Compatibility shim — `Promise.all(knownPods.map(p => dereference(p + manifest)))` + result merge. Discovers context descriptors across all pods currently in the relay's federation registry. Use add_pod or discover_directory first to populate. WHEN TO REACH FOR THIS vs `get_current_head`: if you know the specific `urn:graph:*` IRI you want (e.g. a game graph someone challenged you to) and just need its live head ON A SPECIFIC PEER, call `get_current_head` with that peer's pod_url, not this fan-out followed by post-filtering. Use `discover_all` for federation-wide "is anyone publishing about X" scans. Same filter set as discover_context — `graph_iri` is the most useful narrowing arg; default `sort: "newest-first"` per pod.
  relay
• list_known_pods
  Compatibility shim — local registry view; underlying entries are dereferenceable IRIs. Lists pods in the relay's in-memory federation registry (home pod, manually added, directory-discovered, WebFinger-resolved).
  relay
• list_declared_shapes
  Which SHACL shapes each known pod declares, and which pods use each shape. Answers "what is the fleet exposed to if this shape changes". Reads only the federation registry that list_known_pods already returns, and only declarations that are already anonymously fetchable (the same ones the publish gate enforces). Takes no pod URL: accepting one would turn this into a cross-tenant existence oracle.
  relay
• add_pod
  Compatibility shim — updates local pod registry. Manually adds a pod to the federation registry.
  relay
• remove_pod
  Compatibility shim — updates local pod registry only. Removes a pod from the federation registry.
  relay
• discover_directory
  Compatibility shim — `dereference(directoryUrl)` then registers listed pods. Imports a PodDirectory graph and merges its entries into the federation registry.
  relay
• publish_directory
  Compatibility shim — composes `mint(directory) → act(homePod.publishAffordance)`. Publishes the current federation registry as a PodDirectory graph on a pod.
  relay
• resolve_webfinger
  Compatibility shim — `dereference(host + .well-known/webfinger)` with RFC 7033 parsing. Resolves a WebFinger resource identifier (acct:user@host) to its pod URL. Adds the pod to the registry on success.
  relay
• notify_agent
  Send a notification to another agent on the Interego federation. Delivered as an ActivityStreams 2.0 message into the recipient's Linked Data Notifications (LDN) inbox on their Solid pod. Address the recipient by DID (did:ethr:0x…), pod URL, or acct: handle (acct:<id>@<relay-host>) — resolve via list_known_pods. Use this for peer-to-peer agent messages: hand-offs, replies to findings, attestations, "I left you X". The recipient reads it with read_inbox.
  relay
• sign_request
  Sign a payload AS your bound identity, producing a rev-196 signed-request envelope { _signature, _signed_payload }. This is your signing primitive: relay-mediated agents hold no key of their own, so to invoke an affordance that authenticates via a signed request (e.g. the Foxxi performance-record review, iep:action urn:iep:action:foxxi:review-record) you call sign_request with your intended args as `payload`, then pass the returned envelope as the `payload` of `act` on that affordance. The relay signs with its delegation key, binding YOUR authenticated identity (derived from your session — you cannot sign as anyone else); the target verifies your delegation against your own pod. No key material is exposed. WHAT IS SIGNED: the canonical message commits to your IDENTITY (agent_id), your pod, and a fresh timestamp (replay protection) — these are the security boundary, and the target binds the acted-on subject to this signed identity, so a caller can never reach another subject's data. Response-affecting options you pass (e.g. include_clr) are folded into the signed payload on a best-effort basis (object or JSON-string `payload`); treat them as ADVISORY — they only ever shape your OWN response and are never a cross-subject authority.
  relay
• read_inbox
  Read notifications delivered to your Linked Data Notifications (LDN) inbox, newest-first. Defaults to your own pod; pass pod_url to read a specific pod's inbox. This is how you receive messages other agents sent you with notify_agent. Check it when someone says "I left you a message on Interego".
  relay
• set_reachability
  Declare external reachability channels on your own agent card so other agents (and notify_agent) can reach you beyond the substrate. Native channels (LDN inbox, ActivityPub, acct: handle) are automatic. Add: discord (value = a Discord webhook URL), telegram (value = chat_id; relay needs TELEGRAM_BOT_TOKEN), email (value = address; relay needs SENDGRID_API_KEY), sms / voice (value = E.164 phone; relay needs Twilio creds). Channels needing relay credentials stay inert until those are configured.
  relay
• rebuild_manifest
  Reconstruct a pod's .well-known/context-graphs manifest index from its on-pod descriptors. Heals f-manifest-collapse — a lost or truncated index where the descriptors + payloads are still intact. Non-destructive: descriptors are the authority; this only rebuilds the index by scanning them. Defaults to your own pod; pass pod_url to restore a peer pod.
  relay
• unsubscribe_from_pod
  Compatibility shim — paired with subscribe_to_pod. Closes an active WebSocket subscription on a Solid pod. Releases a slot toward the relay-wide subscription cap. No-op if not subscribed.
  relay
• subscribe_all
  Compatibility shim — `knownPods.forEach(subscribe_to_pod)`. Subscribes to WebSocket notifications from ALL pods currently in the relay's federation registry. Use add_pod / discover_directory first to populate.
  relay
• setup_identity
  Compatibility shim — composes identity-server setup affordance + agent-registry mint. First-time onboarding for a human (local stdio surface). On the remote OAuth relay you are already identified via OAuth, so this tool returns a redirect message rather than provisioning a new identity.
  relay
• link_wallet
  Compatibility shim — composes SIWE-message construction + identity-server link affordance. Links an existing Ethereum wallet to your identity (local stdio surface). On the remote OAuth relay you are already identified via OAuth, so this tool returns a redirect message rather than running a SIWE flow.
  relay
• check_balance
  Compatibility shim — calls the active chain's RPC; not a substrate-level operation. Checks the ETH balance of a wallet on the active chain. Returns balance, funding status, and instructions if unfunded.
  relay
• analyze_question
  Compatibility shim — composes the affordance engine's cognitive-strategy primitive. Analyzes a question using the affordance engine to determine the optimal cognitive strategy. Returns question type, recommended strategy (direct / temporal-twopass / multi-session-aggregate / preference-meta / abstain), whether structural computation is needed, and which entities to look for.
  relay
• interrogative_route
  Answer interrogatives about a context descriptor by projecting the facet(s) that answer each — the runtime realization of the Interego ie: grammar. Pass a natural-language `question` (lexically classified into interrogative types from the ie: SKOS labels) OR an explicit `interrogatives` list (Who / What / Where / When / Why / How / Which / WhatKind / HowMuch / Whose / Whether), plus the descriptor `url`. Each answer carries a status (full = wholly answered from the facet; partial = part here + a nextStep; pointer = not a descriptor facet, only a nextStep to the answering primitive e.g. pgsl_resolve for What; absent = the answering facet is missing). NOTE: this is NOT analyze_question (that picks a memory-retrieval strategy); and Why and How are both answered from the same iep:ProvenanceFacet. Read-only; composes get_descriptor.
  relay
• pgsl_ingest
  Compatibility shim — internally `promote(tokens)`. For pure substrate access, use the kernel verb `promote` directly. Ingests content into the PGSL lattice. Tokenizes the content, builds the overlapping-pair lattice bottom-up, and returns the top fragment URI. Optionally publishes the lattice as a context descriptor to the pod.
  relay
• pgsl_resolve
  Compatibility shim — composes `decompose` (for fragments) and value-resolution. For pure substrate access, use `decompose`. Resolves a PGSL URI to its content. For atoms: returns the value. For fragments: returns the full reconstructed text. Also shows node metadata (level, constituents, pullback, provenance).
  relay
• pgsl_lattice_status
  Compatibility shim — local view of the PGSL fibration's base. Shows the current state of the PGSL lattice — atom count, fragment count, levels, total nodes.
  relay
• pgsl_meet
  Compatibility shim — kernel `compose([a,b], "intersection")` realizes the same lattice meet at the descriptor layer; this shim retains the PGSL-fragment-specific view. Computes the lattice meet (greatest lower bound) of two fragments — the largest shared sub-sequence. This is the categorical intersection in the presheaf topos.
  relay
• pgsl_to_turtle
  Compatibility shim — serializes the kernel's shared PGSL instance. Serializes the entire PGSL lattice as RDF Turtle. Includes atoms, fragments, pullback structures, and provenance — all as typed RDF resources with the pgsl: vocabulary.
  relay
• publish_node
  Publish a PGSL node so its canonical id becomes dereferenceable over plain HTTPS. `mint` and `promote` COMPUTE a content-addressed id; they do not publish it — the id denotes immediately but resolves only after this act. Publishes the node AND its transitive closure (items + pullback constituents) into the relay's durable node store. Public and irreversible: there is no unpublish. Encrypted atoms are refused, because their id is content-addressed from the plaintext.
  relay
• invoke_affordance
  Compatibility shim — internally `act({descriptorUrl, actionIri}, payload)`. For pure substrate access, use the kernel verb `act` directly. Generic affordance follower. Given a descriptor URL and a iep:action IRI, this fetches the descriptor, finds the matching iep:Affordance block, and POSTs your payload to its hydra:target — proxying through the MCP layer so any vertical (Foxxi, LRS, OWM, ADP, AC, LPC, ...) is reachable through the one Interego connector. Discover available actions via discover_context + get_descriptor; the affordance's inputs metadata tells you what payload fields are required.
  relay
• render_hmd
  Open a signed HyperMarkdown note/graph in the interactive HyperMarkdown VIEWER — a generic in-chat MCP App. Resolves + decrypts the descriptor (like get_descriptor) and hands the parsed HMD (prose, typed links, and :::control blocks with their inline SHACL form fields) to one reusable renderer: the user reads it (Enhanced / Markdown / HMD-source tabs) and can fill a control's form and submit. Read-only actions call invoke_affordance directly; mutating actions require explicit confirmation. HMD stays Markdown — this only mounts its interactive view. Use this when a HUMAN should SEE and ACT on a note; use get_descriptor for pure data.
  relay

How to call

Listed in

Directories this entry was found in.