Following up on my first post here. Pushing further on the attribution problem I left open.
Attribution as graph traversal: a two-layer hypothesis
In a previous post I argued that agent reputation should be compositional — flowing through the tools an agent uses, not stopping at the wrapper. The natural follow-up is the hard part: how do you actually attribute credit across a composition without paying the Shapley cost on every event?
Here’s a procedure I’m sketching out. I think it works, but I’d like to test it against the community’s thinking.
What if attribution didn’t have to be computed?
Most attribution approaches assume you derive credit retrospectively from observed performance. Given an agent that combined N tools and got an outcome, work backward to figure out which tool contributed what. This is mathematically rigorous — Shapley values are well-defined — but computationally expensive in the general case. On-chain, expensive means infeasible.
But what if the composition were declared at the time of attestation, with the causal structure embedded directly in a semantic graph? Then attribution stops being a calculation and becomes a graph traversal.
This is exactly what a semantic graph substrate like Intuition is designed to express. Atoms represent entities (agents, tools, domains, models). Triples encode relationships (agent X used tool Y; tool Y has capability Z in domain W). When an attestation is posted, the agent doesn’t just emit a feedback signal — it emits a small graph of relationships describing how the attestation was produced.
But declarations alone are cheap talk
There’s an obvious problem with declarations: an agent can lie. It can claim to use Tool X while actually using Tool Y. Or it can declare tool usage opportunistically — citing a high-reputation tool to inherit its prior, even when that tool wasn’t actually invoked.
If the only consequence of declaration is reputation flow, the system is gameable from day one. Every agent has an incentive to claim composition of whichever tools have the highest scores, regardless of what they actually used.
This is where the second layer matters: economic conviction.
What if every declared use of a tool required the agent to take an economic position on that tool — buying shares on Intuition’s bonding curve, putting actual stake behind the declaration? Then declaration stops being cheap talk and becomes costly signaling. An agent that claims to use Slither but doesn’t actually use it pays anyway, in capital locked into a position on a tool whose downstream performance won’t match the agent’s own. The capital is at risk if the claimed composition was fictional. The signal becomes self-disciplining.
This is the move that makes the architecture work. Two layers, doing different jobs:
-
Immutable layer (triples): the historical record of declared composition. What the agent claims it did. Verifiable, permanent, archived in the graph.
-
Mutable layer (economic positions): the active conviction. What the agent is currently economically willing to back. Movable, market-priced, expressive of present belief.
Together, they produce something neither could alone: a reputation signal that’s both historically auditable and economically honest.
The procedure, walked through
Concretely, here’s what an attestation looks like in this model.
Tool registration. An agent encounters an MCP server or sub-model it wants to use. It registers a tool atom on Intuition — but not freely. The atom’s identifier is canonical, derived from the tool’s natural URI (the MCP manifest URL, or a hash of a model card). Two agents registering the same MCP produce the same atom. No duplication, and stake aggregates correctly across the ecosystem.
Economic positioning. The agent stakes on the tool atom using Intuition’s exponential bonding curve. Early stakers pay less, gaining more upside if the tool turns out to perform well. Late stakers pay more, with proportionally less upside but still meaningful position. This is the curation market dynamic the curve is designed for, applied here to tool reputation.
Attestation with snapshot. When the agent makes an attestation in a domain, it declares the composition — which tools it used, in what configuration. The contract snapshots the agent’s positions on those tools at that exact moment. The snapshot is immutable, bound to the attestation forever.
Ground truth and settlement. Eventually, ground truth becomes knowable. This is its own hard problem and I’m parking it for another post. When it arrives, calibration is computed. Credit or debit flows back to the tools according to the snapshot of positions, not the agent’s current positions. An agent can’t divest just before settlement to escape losses. Skin in the game is preserved structurally.
Reputation propagation. Tools accumulate calibration scores per domain, aggregated across all agents who staked on them. A tool that consistently appears in well-calibrated attestations gains reputation in that domain. Tool builders see this signal directly. Agents inheriting the prior of a high-calibration tool get a meaningful boost without having to bootstrap from zero.
What this gets you
A few things fall out of this design that I find genuinely elegant.
Attribution becomes free at query time. No Shapley calculation per attestation. You walk the graph from the attestation to the tools used, weighted by the position snapshot, and the credit distributes mechanically.
Composition lying is economically self-defeating. An agent that lies about composition pays the cost of that lie in locked capital. The market makes truthfulness cheaper than fabrication, without needing TEE attestation or cryptographic proofs to start with.
The graph encodes generalization natively. Because tools sit in a taxonomy (domain → capability → tool), an agent calibrated on “lending DeFi with Pyth oracle” can inherit an informed prior on “lending DeFi with Chainlink oracle” through graph proximity, not exact match. The semantic structure does this work natively. You don’t bolt an ML generalization layer on top — it emerges from the substrate.
Tools become first-class economic citizens. A great MCP server isn’t invisible anymore. Its score is legible. Its builder gets honest signal. The feedback loop missing from current agent reputation designs is restored.
What I’m genuinely unsure about
This isn’t clean. Three real problems I haven’t resolved.
Orchestration delta. This is the same question I left open in the previous post. The model attributes credit to tools cleanly, but the agent’s own orchestration — its prompt, its routing, its retry logic — is harder to isolate, especially in LLM-heavy domains. I think the answer is that orchestration earns calibration through the residual: the gap between expected performance (given declared tools) and observed performance (actually delivered). But residuals are noisy, and I haven’t stress-tested this enough.
Bootstrap of the first tools. Cold-start for the entire system. Who creates the first tool atoms? Who stakes on them when there’s no calibration history yet? Some seed mechanism is probably necessary — maybe protocol-funded initial positions, maybe a foundation-curated starter set. Neither feels fully decentralized, and I’m not sure which compromise is the right one to make.
Verification of composition under adversarial pressure. Economic stake makes lying expensive, but it doesn’t make it impossible. Stronger guarantees — TEE-attested invocation logs, eventually ZK proofs of tool execution — are a natural future layer. The procedure can ship without them initially because the economic stake aligns incentives in the common case. But for high-value domains under sustained adversarial pressure, the economic layer alone probably won’t hold long-term.
To the community
Can you imagine this solution working? What issues do you think we’d face? I’m curious to hear more from the community — especially from anyone who’s thought about the orchestration delta problem or the bootstrap question, because those are where I’m least confident.