Knowledge Provenance
Two attribution layers. Every fact traceable.
Iranti attributes any stored fact to both (a) the agent ID that stored it and (b) the source label the agent declared at write time. This two-layer chain — session identity plus semantic source — lets downstream agents and operators ask not just what is known, but who established it and under what role.
Results at a glance
iranti_who_knows carried a two-layer attribution chain: agentId (the authenticated session) and source (the declared semantic identity). No application-level tagging was required — the storage layer preserved both automatically.What this measures
In a multi-agent system, knowledge accumulates fast. Facts get written by many agents across many sessions. Without provenance, a downstream agent has no way to evaluate the trustworthiness of a stored fact — it cannot tell whether the fact came from a high-confidence research agent or an early brainstorm.
B10 tests whether Iranti's iranti_who_knows API correctly returns two independent attribution layers for every stored fact: the session-level identity of the writer (agentId) and the semantic role the agent declared itself as (source).
Five facts about a research project were written under the project/stellar_echo/ namespace. Each was stored by benchmark_program_main acting as research_agent. iranti_who_knows was then called on the namespace — returning all five facts with both attribution fields present.
The benchmark does not test attribution across multiple distinct agentIds or sources. All five facts share the same writer identity. Cross-source disambiguation is not verified here.
The two-layer attribution chain
Each stored fact connects to two independent provenance layers. Amber = session identity (agentId). Teal = declared semantic source (source).
What each layer means
The two layers answer different questions. AgentId answers who ran the code. Source answers what role that agent was playing.
Automatically captured from the authenticated session that called iranti_write. This is who actually ran the code — the process or agent runtime that holds the session token.
Declared by the agent at write time as a named attribute. This is who the agent claims to be acting as — a role, persona, or sub-agent identity. It is asserted, not verified.
The evidence — 5-fact attribution grid
All five facts stored under project/stellar_echo/, with the agentId and source fields returned by iranti_who_knows.
| Key (project/stellar_echo/) | Value | agentId | source | Attributed |
|---|---|---|---|---|
| primary_researcher | "Dr. Elena Vasquez" | benchmark_program_main | research_agent | |
| research_focus | "quantum error correction algorithms" | benchmark_program_main | research_agent | |
| institution | "MIT Quantum Computing Lab" | benchmark_program_main | research_agent | |
| current_phase | "Phase 2: algorithm optimization" | benchmark_program_main | research_agent | |
| expected_publication | "Q4 2026" | benchmark_program_main | research_agent | |
| Total | 5 facts | 5/5 agentId | 5/5 source | 5/5 |
API response shape
The full response structure returned per fact by iranti_who_knows. Both attribution fields, value, and timestamp are present on every fact in the response.
{
"entity": "project/stellar_echo",
"key": "primary_researcher",
"value": "Dr. Elena Vasquez",
"agentId": "benchmark_program_main",
"source": "research_agent",
"validFrom": "2026-03-21T09:14:22.441Z",
"confidence": 0.9
}validFrom timestamps were present on all five returned facts, making provenance time-aware — a downstream agent can determine how old a fact is and factor recency into its reasoning.
Honest limitations
source=research_agent is a declared attribute, not a verified session identity. Any agent with write access to the namespace can declare any source label. The attribution is useful for semantic organization but should not be treated as a trust boundary.iranti_who_knows correctly distinguishes between facts written by different agents under the same namespace. That is a separate capability not tested here.project/stellar_echo. Cross-namespace provenance queries were not tested.Key findings
agentId and source were preserved by the storage layer without any application-level tagging. Provenance requires no extra engineering effort at write time.iranti_who_knows returns full attribution context. A single API call on a namespace returns all stored facts with complete provenance — value, agentId, source, validFrom, and confidence — enabling downstream agents to make trust-weighted decisions.validFrom timestamps on all five facts mean downstream agents can determine recency and weight older knowledge appropriately.benchmark_program_main) can act as multiple semantic sources across different operations. This lets runtime identity stay stable while declared roles shift with context.Full trial execution records, agent logs, provenance payloads, and methodology notes in the benchmarking repository.