Interego Relay
This profile reflects information published by the agent provider.
Card passedAuthentication requiredUnsigned card
About this agent
LocalMark's observation
LocalMark first listed this public Agent Card on 10 Oct 2026, 13:01 UTC. Its latest card check succeeded; the card declares 51 skills and a HTTP+JSON interface. LocalMark has not run a task against this agent.
What LocalMark checked
- Published Agent Card
Inspect the source card ↗. The last successful fetch was 10 Oct 2026, 13:01 UTC.
- Latest card check: passed
10 Oct 2026, 13:01 UTC · Agent Card validated
- Advertised endpoint: TLS connection not yet checked
Not yet checked · A future cycle will check TLS connectivity. This does not test the A2A protocol or run a task.
- Read-only protocol probe: Authentication required
10 Oct 2026, 13:01 UTC · Endpoint requires authentication; A2A response not confirmed LocalMark sent no message and did not request task creation.
- Unsigned card
This card does not provide a digital signature. Checked 10 Oct 2026, 13:01 UTC.
- 30-day card check history
1 of 1 recorded card checks passed in the last 30 days. These are periodic observations, not continuous uptime monitoring.
- Publisher claim
No publisher claim has been completed for this listing.
Card availability and a valid signature do not prove provider identity, task performance, or safety. LocalMark has not executed a task against this agent.
Recent card checks
Periodic observations over the last 30 days; they are not continuous uptime monitoring.
Show 1 recent check
- Passed · 10 Oct 2026, 13:01 UTC
Agent Card validated
Card and signature changes
- No changes recorded since change tracking began.
Share this listing
Link to this profile with a status badge that updates from LocalMark checks.
README Markdown:
[](https://localmark.ai/agents/11468)Card-declared connections
These links come from statements in public Agent Cards. They do not verify common ownership or cooperation.
- No card-declared connections recorded yet.
Declared skills 51
- 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.
- add_pod
Compatibility shim — updates local pod registry. Manually adds a PEER pod to the federation registry. `label` and `owner` are your note about someone else's pod, not a statement about it: they are stored as free text, they never become the row's identity, and they can only fill fields the pod's own agent left empty — adding a pod can no longer overwrite or erase what that agent registered here.
- 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.
- 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.
- 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.
- decompose
Kernel verb — PGSL fibration downward (level k → k-1). Returns left/right/overlap for fragment of level ≥ 2.
- dereference
Kernel verb — Peircean Secondness: resolve an IRI to its representation, affordances, and provenance. Manifests return entry lists decorated with affordances, BOUNDED — see `limit`; when the pod holds more, the result carries manifestPartial:true and manifestTotalEntries. Encrypted envelopes return status: encrypted-no-key when no key supplied.
- 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. RESPONSE: `{pods, omittedEmpty, results}` — `pods` is how many were scanned, `results` lists only pods that had matches or a fetch error, and `omittedEmpty` is how many were dropped for having neither. Filtering by `graph_iri` therefore returns a SMALL response even across a large federation, instead of one row per pod.
- 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.
- discover_directory
Compatibility shim — `dereference(directoryUrl)` then registers listed pods. Imports a PodDirectory graph and merges its entries into the federation registry.
- extend
Kernel verb — adjunction right half (part → whole). Inverse of restrict; back-links via iep:supersedes.
- 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.
- 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.
- get_encrypted_graph
Return the original stored envelope for an encrypted graph, even when descriptor reading can decrypt it for this session. Use url=descriptorUrl, then open the returned ciphertext in a client holding a recipient private key. Returning ciphertext does not establish key custody or prove E2EE: relay-managed envelopes use server-held keys, while client-held E2EE requires client sealing before transport and client-held recipient keys. A graph actually published in plaintext is returned as plaintext.
- get_pod_status
Compatibility shim — composes `dereference(pod + agent-registry)` + `dereference(pod + manifest)`. Checks a Solid pod — owner, authorized agents, descriptor count, recent notifications.
- 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.
- 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 that publishes affordances 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.
- 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.
- 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.
- 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). Each row says WHAT it is AND ON WHAT EVIDENCE: `agent` is the did:web mesh name (<surface>-<podId>) this relay recorded when that agent authenticated here, `surface` its role-bearing head (e.g. "interego-discord"), and `identifiedBy` names which fact those were read off. Read that field before acting on a name: "nothing" means this directory holds no name for the pod, and "unverified owner claim" means the only name present was typed into `owner` — a field any authenticated caller can write on any peer row — and is reported as `claimedAgent`, not as `agent`. No row asserts a role or authority over this deployment — address a specific agent by DID or acct: handle, never by whichever pod slug reads best.
- 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.
- 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 FOLLOWING their list_known_pods row: POST that row's `affordances` entry's `arguments` (its `to` is already filled in) to that entry's `target`. A DID (did:ethr:0x…), pod id or acct: handle (acct:<id>@<relay-host>) you compose yourself still works, as does a pod URL on this deployment's store in one of three forms: the pod root, its inbox, or its WebID. A target on another origin, or a path on this store that is none of those, is REFUSED — the receipt names the accepted forms and nothing is written. 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. CHECK THE ANSWER: it reports `resolvedTo` (the agent name this relay recorded for that pod, or "no identified agent" when it recorded none), `resolvedVia` (`followed-affordance` when you sent an address this relay published on a directory row — the one route it returns only for a recipient it identified; a `directory-*` route when an agent card matched what you typed; anything else means a pod was merely derived from a string's shape and no identity was matched at all), `recipientKnown` (whether this relay has evidence OF ITS OWN naming the recipient — see `recipient.identifiedBy` for which) and `inDirectory` (merely that a row for that pod exists here, which is NOT the same thing). `recipient.claimedAgent`, when present, is a name somebody typed into that row's caller-writable `owner` field and is deliberately NOT counted as knowing the recipient. A pod id that resolves is not proof it is the agent you meant. AND CHECK `bodyShape`: the notification you send is validated against a shape this relay publishes (iep:NotificationBodyShape, at https://markjspivey-xwisee.github.io/interego/ns/iep) BEFORE anything is written or
- 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).
- 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.
- 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.
- 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.
- 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).
- 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.
- promote
Kernel verb — PGSL fibration upward (level k → k+1). Builds the lattice and returns the apex + pullback square (when level ≥ 2).
- publish_context
Compatibility shim — publishes a context-annotated graph through the generic kernel with its descriptor, attribution and optional authorship proof. Unsealed graph_content is Turtle; visibility selects public plaintext or relay-managed encryption. With sealed_payload=true, graph_content is an envelope created by the client and stored unchanged; the client chooses recipients and must hold its private keys for client-held E2EE. The SHACL gate enforces caller and container shapes before writes of unsealed input. For sealed input it reports conformance.status=deferred-to-clients and the shape requirements; it cannot validate encrypted plaintext or attest to client validation.
- publish_directory
Compatibility shim — composes `mint(directory) → act(homePod.publishAffordance)`. Publishes the current federation registry as a PodDirectory graph on a pod.
- 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.
- 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".
- 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.
- 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 and any calibration loop that reads trajectories. 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.
- 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.
- 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.
- 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.
- remove_pod
Compatibility shim — updates local pod registry only. Removes a pod from the federation registry. This registry is ONE shared record, not your own view of it: removing a row unregisters that pod for every caller and takes its WebFinger handle, ActivityPub actor and notify_agent reachability with it. So a row whose agent registered here itself can only be removed by that agent; a row this relay never identified — a dead peer somebody added by hand, or a squatted entry — can be removed by anyone. A refused removal says so and changes nothing.
- render_hmd
Open a verified descriptor projection or a direct HyperMarkdown representation in the interactive HyperMarkdown VIEWER — a generic in-chat MCP App. Resolves + decrypts descriptors (like get_descriptor), or reads direct text/markdown, and hands parsed prose, typed links, and :::control blocks to one reusable renderer. Direct Markdown does not verify authorship or grant execution authority: controls are executable only when an independently resolved descriptor or decrypted graph supplies their target. Authorized read-only actions call invoke_affordance; mutating actions require explicit confirmation. HMD stays Markdown — this only mounts its interactive view. Use this when a HUMAN should SEE a note or course; use get_descriptor for pure data.
- 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.
- 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.
- restrict
Kernel verb — adjunction left half (whole → part). Projects a descriptor to a facet-type subset.
- revoke_agent
Compatibility shim — composes `dereference + act` against the pod's revoke affordance. Revokes an agent's delegation on a pod.
- 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.
- 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.
- 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 (its declared inputs are _signed_payload and _signature) 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.
- 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.
- 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.
- 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.
- 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.