Key takeaways
- ANS answers whether an agent is who it claims to be, and the Trust Index spec answers how much to trust it and for which actions. Because that depends on what you are delegating, the answer is five dimension scores and a recommended profile rather than a single number.
- A dimension scoring 0 is not a verdict. Dimension weights are switches, so the three dimensions with no signals registered in v1 are inactive rather than failing, which is why
agent-001lands onREAD_ONLYinstead ofUNTRUSTED. - Every low score names its own fix. The risk code
IDENTITY_CERT_DV_ONLYtells an agent owner to re-register with a stronger certificate: an OV certificate moves this agent toTRANSACTIONAL, while only an EV certificate reachesFIDUCIARY.
Your agent is about to hand a billing agent $10,000. It already ran the checks from our last post on Agent Name Service (ANS): the billing agent carries an identity (a passport), it's in good standing (not expired), and it proves possession of the key matching its registered credential. But should you trust it with the money? ANS registration doesn't answer that. The Trust Index spec exists to help answer it, and Agent Trust Discovery is an open source framework that implements it.
A trust index imports the Transparency Log that ANS publishes, combines that sealed data with external signals, and computes a Trust Evaluation, the spec's name for the payload it returns. The Transparency Log is the append-only record of registration events that ANS maintains; a value is sealed once it has been written there, so it can't be altered after the fact without detection. The evaluation answers one question: given what is publicly verifiable about an agent, what class of tasks should a client delegate to it?
ANS registrations vary in completeness. A few fields are required: the server certificate, the agent version, and two DNS TXT records. The _ans record publishes where to reach an agent, and the _ans-badge record advertises its ANS registration. Others are optional, such as the identity certificate, the DNS TLSA record that pins which certificate a service may present, and the HTTPS record.
The more an agent verifiably registers, the more angles there are to evaluate it, and the more trust it can potentially earn. That holds only for the fields a signal actually reads, though. The identity certificate is one, so leaving it out scores its signal at 0 and costs the agent integrity points. Nothing in v1 reads the TLSA or HTTPS records, so skipping those two is free for now.
Agent Trust Discovery shows how the Trust Index spec could work in practice. The code is written for teaching. It makes the trust computation easy to follow and intentionally skips some performance optimizations to keep the logic simple. The spec fixes the five dimensions but leaves the scoring to each provider, so the weights and thresholds here are Agent Trust Discovery's choices rather than the spec's.
Architecture
Agent Trust Discovery is a single service built from a few internal components on top of a storage engine (SQLite). It also comes with a set of companion services (inside the Evidence producers box) used to import agents and produce observations. The read client talks to it through a set of HTTP endpoints. The following image shows how those components fit together:

Import service: Every piece of state enters here: agent records and observations. Its job is kept narrow: validate, write the batch, return.
- Agents get shape checks only: required fields, a valid status, well-formed timestamps, and size caps so a buggy producer can't push multi-megabyte strings into storage.
- Observations get a second round, because each is a bundle of references that must resolve: Does the agent exist? Does the system recognize the signal? Does the value match what that signal expects?
Search service: A thin HTTP layer that routes read requests down two paths.
- Search (
GET /v1/ans/registered-agents, orPOST /v1/ans/search-registered-agentsto pass a filter body) takes a free-text query plus filters and returns a ranked list of matching agents with their registration details, straight from the database's full-text index. Trust scores are computed per request rather than stored, so scoring a page of 50 hits would mean 50 evaluations to render a list most callers are only skimming. Search narrows the field, and scoring happens on the subset of agents worth a decision. - Detail (
GET /v1/ans/registered-agents/) goes to the scoring engine, which fetches the agent's observations and computes the score live. The response is a full breakdown: the score, any risk codes, and a recommended profile.
Scoring engine: A trust score is computed live when a detail request comes in, and only from observations already in the database. The loop is short:
- For every signal in the registry, it fetches that agent's most recent observation from the database.
- It hands the observation to the signal, which turns it into a number (0–100), a plain-language explanation, and any risk codes. The engine never interprets the value itself; the signal does.
- It averages those numbers within each of the five dimensions, weighted by the configured signal weights.
- It runs a first-match cascade over the resulting dimension scores to land on a recommended profile.
Signal registry: Both the import service and the scoring engine need to know what each signal expects, and neither holds that knowledge itself. It lives in the signal registry: a catalog of every signal the engine knows about. The registry does no work of its own; it answers questions.
- The import service asks does this signal exist, and is this value valid for it? The registry returns the signal and lets it judge its own payload. Derived signals are the exception:
agentagecomputes its score from the agent record, so it accepts no observations at all, and the import service rejects any producer that tries to send one. - The scoring engine says to give me every signal, in order. It walks the list, and each signal tells it which dimension it belongs to, how to turn an observation into a number and an explanation, and what risk code to raise when the observation warrants a caution.
Signal dimensions
The Trust Index spec defines five dimensions, and an agent's scores across them are its trust vector. Agent Trust Discovery ships signals for two of the five today, and the other three are open for contribution:
- Integrity: Is this agent mechanically sound?
- Identity: Who stands behind this agent?
- Solvency: Can this agent pay for damages?
- Behavior: How does this agent treat others?
- Safety: Will this agent leak data or cause harm?
Each dimension holds one or more signals (each scored 0–100) that combine into the dimension score via a configurable weighted average, and you can define and plug in your own signal providers. Signals also emit a risk code when an observation shows a specific weakness or mismatch, so a consumer gets a concrete warning rather than a bare number.
Signals come in the following two types:
- Raw-observation signals map a value straight to a score: an EV (extended-validation) certificate scores 100, an OV (organization-validated) certificate 70, and a DV (domain-validated) certificate 40.
- Drift-verdict signals compare an observed value against a sealed baseline (a served certificate fingerprint, say): a match scores 100, a mismatch (drift) scores 0.
Raw-observation signals
The following table lists the raw-observation signals, how each one maps an observed value to a score, and the risk code it can emit. Two acronyms appear in it: DNSSEC signs DNS answers so a resolver can detect tampering, and a Certification Authority Authorization (CAA) record names which authorities may issue certificates for a domain:
| Signal | Dimension | Raw score 0–100 | Risk code emitted |
|---|---|---|---|
certtype | identity | EV→100, OV→70, DV→40, none→0 | IDENTITY_CERT_DV_ONLY (DV), IDENTITY_CERT_MISSING (no obs) |
dnssecurity | integrity | DNSSEC + CAA → 100, exactly one → 50, neither → 0 | INTEGRITY_DNSSEC_BROKEN when the DNSSEC bit is absent |
agentage (derived) | integrity | round(100 × days / 180), capped at 100, computed from agent.FirstSeen | INTEGRITY_AGENT_NEW when raw < 25 |
versionstability | integrity | round(100 / (1 + versionChanges30d)) | INTEGRITY_VERSION_CHURN_HIGH when changes ≥ 4 |
Drift-verdict signals
Agent Trust Discovery ships four drift-verdict signals: two that compare certificate fingerprints and two that compare DNS records. All four are integrity signals, and all are binary: match→100, mismatch→0 plus a risk code, and an unsealed baseline → 0 ("not sealed").
The following table lists each drift-verdict signal, the value it compares against the sealed baseline, and the risk code it raises on drift:
| Signal | Subject | Risk code |
|---|---|---|
certfingerprint.server | served TLS cert fingerprint vs sealed baseline | INTEGRITY_SERVER_CERT_FINGERPRINT_DRIFT |
certfingerprint.identity | identity cert fingerprint | INTEGRITY_IDENTITY_CERT_FINGERPRINT_DRIFT |
dnsrecord.ans | live _ans TXT record | INTEGRITY_DNS_ANS_DRIFT |
dnsrecord.ans-badge | live _ans-badge TXT record | INTEGRITY_DNS_ANS_BADGE_DRIFT |
Scoring
Two sets of weights shape the score: signal weights decide how signals combine within a dimension, and dimension weights decide which dimensions count at all.
Signal weights: Each dimension score is the weighted average of its component signals. Stated in text: sum (signal score × signal weight) across the dimension's signals, divide by the sum of those weights, and round to the nearest integer. The following image shows the same formula:

Dimension weights: These are switches rather than multipliers, and the engine accepts only 0 or 1 to turn a dimension on or off. The engine does not compute a combined score across dimensions. Each one measures a different aspect, and a low score in a single dimension can flag something serious that high scores elsewhere shouldn't average away.
That independence holds between dimensions, not inside them. Within a dimension, the weighted average can still dilute a single bad signal, which is one reason an evaluation carries risk codes next to its scores. The demo makes that concrete.
Recommended profile
After the engine scores an agent, it runs a cascading classifier to assign a recommended profile (a label based on the composition of its dimension scores). The possible values are UNTRUSTED, READ_ONLY, TRANSACTIONAL, and FIDUCIARY, and they tell a caller what an agent is suitable for: a READ_ONLY agent is a poor fit for purchases but a good candidate for research and lookups.
The cascade runs in order over the scoring profile's active dimensions and stops at the first match. (A dimension is active when its weight is on and it carries at least one weighted signal.)
Cascade rules (evaluation order)
The following table lists the cascade rules in evaluation order:
| # | Condition | Result |
|---|---|---|
| 0 | No dimension is active | READ_ONLY |
| 1 | Any active dimension < 20 | UNTRUSTED |
| 2 | All active dimensions >= 80 and identity is active and >= 90 | FIDUCIARY |
| 3 | All active dimensions >= 50 | TRANSACTIONAL |
| 4 | Fallback | READ_ONLY |
Configuration
The engine exposes a few knobs: the weight of each signal and which dimensions are active during scoring. In the following default profile, only integrity and identity are active (dimensionWeights: 1.0), and every signal carries equal weight (1.0):
name: default
dimensionWeights:
integrity: 1.0 # active — drives the recommendedProfile cascade
identity: 1.0 # active — drives the recommendedProfile cascade
solvency: 0.0 # empty in v1; no signals registered
behavior: 0.0 # empty in v1; no signals registered
safety: 0.0 # empty in v1; no signals registered
signalWeights:
# raw-observation signals
certtype: 1.0 # identity
dnssecurity: 1.0 # integrity
agentage: 1.0 # integrity (derived)
versionstability: 1.0 # integrity
# drift-verdict signals — active by default
certfingerprint.server: 1.0 # integrity
certfingerprint.identity: 1.0 # integrity
dnsrecord.ans: 1.0 # integrity
dnsrecord.ans-badge: 1.0 # integrityA worked example
The following is an excerpt from a full make demo run: the results for a sample agent, agent-001, scored with the default profile:
STOP 3 — Detail for agent-001 (Trust Evaluation breakdown)
──────────────────────────────────────────────────────────────
Signals are grouped by dimension; each dimension score = weighted average of its raw scores.
trustVector: {'integrity': 90, 'identity': 40, 'solvency': 0, 'behavior': 0, 'safety': 0}
recommendedProfile: READ_ONLY
verificationTier: None
riskFactors: ['IDENTITY_CERT_DV_ONLY']
scoringProfile: default
signals by dimension:
integrity (score 90)
dnssecurity raw=100 w=1 unattested dnssec + caa present
agentage raw=100 w=1 unattested 248 days old; ramp to 100 at 180
versionstability raw= 33 w=1 unattested 2 version changes in 30d
certfingerprint.server raw=100 w=1 tl_attested serverCert fingerprint matches sealed value
certfingerprint.identity raw=100 w=1 tl_attested identityCert fingerprint matches sealed value
dnsrecord.ans raw=100 w=1 tl_attested _ans TXT matches sealed value
dnsrecord.ans-badge raw=100 w=1 tl_attested _ans-badge TXT matches sealed value
identity (score 40)
certtype raw= 40 w=1 unattested DV certificate; raw 40
solvency (score 0) — no signals in v1
behavior (score 0) — no signals in v1
safety (score 0) — no signals in v1
Four details in that output need unpacking before the numbers make sense.
verificationTier prints as None because v1 never emits one. The spec defines Bronze, Silver, and Gold tiers, but assessing them takes DNSSEC, DANE, and Transparency Log inclusion checks that v1 leaves for later, so the field stays null rather than guessing.
The agentage line reports each fixture's age on the day the run happened, so your own run will show larger numbers than the ones here. The score stays 100 either way, since the ramp caps at 180 days.
Each signal line ends with an attestation tier, which records how strong the evidence behind it is. tl_attested means the expected value came from a Transparency Log event, so it's sealed and independently checkable. unattested is the default and means the value arrived without that backing. The default profile weights both tiers at 1.0, so a sealed signal counts no more than an unsealed one. That's only the default. Signal weights are yours to choose, so if you trust sealed evidence more, weight those signals higher in your own profile and ask for it with ?profile=.
The three dimensions reporting score 0 are not failures. Solvency, behavior, and safety register no signals in v1 and carry dimensionWeights: 0.0, which makes them inactive, and the cascade skips inactive dimensions entirely. That's why agent-001 lands on READ_ONLY rather than UNTRUSTED despite three zeros in its trust vector. A 0 on an active dimension means something different, and rule 1 would catch it.
In the preceding sample, the integrity dimension has seven signals: six score 100 and versionstability scores 33.
Because every signal weight is 1.0, the dimension score is a plain mean: (100 × 6 + 33) / 7 = 633 / 7 = 90.4, which rounds to 90. The following image shows the same calculation:

The certtype signal in the identity dimension has a score of 40. A single low score without explanation is not informative, so the result also carries riskFactors: ['IDENTITY_CERT_DV_ONLY'], which tells the agent owner exactly how to improve the score: upgrade the certificate type.
The choice of upgrade matters. An OV certificate scores 70, lifting identity to 70. That clears rule 3's bar of 50 but misses rule 2, which requires identity to reach 90, so the agent would come back TRANSACTIONAL. Only an EV certificate, scoring 100, satisfies rule 2 and reaches FIDUCIARY. That last step only works with the bundled fixtures. The evidence producer that probes live agents doesn't detect EV yet, so identity caps at 70, below the 90 rule 2 needs.
Following the cascade rules, the returned agent lands on a recommended profile of READ_ONLY. The following image shows how the cascade reaches that result:

When a high score hides a problem
agent-001 is the case where a low score names its own fix. The demo ships the opposite case too. The following breakdown comes from the same run with stop 6 modified to print a full Trust Evaluation, this time for agent-006:
STOP 6 — DNS _ans drift on agent-006 (pre-rigged fixture)
──────────────────────────────────────────────────────────────
Signals are grouped by dimension; each dimension score = weighted average of its raw scores.
trustVector: {'integrity': 86, 'identity': 100, 'solvency': 0, 'behavior': 0, 'safety': 0}
recommendedProfile: FIDUCIARY
verificationTier: None
riskFactors: ['INTEGRITY_DNS_ANS_DRIFT']
scoringProfile: default
signals by dimension:
integrity (score 86)
dnssecurity raw=100 w=1 unattested dnssec + caa present
agentage raw=100 w=1 unattested 263 days old; ramp to 100 at 180
versionstability raw=100 w=1 unattested 0 version changes in 30d
certfingerprint.server raw=100 w=1 tl_attested serverCert fingerprint matches sealed value
certfingerprint.identity raw=100 w=1 tl_attested identityCert fingerprint matches sealed value
dnsrecord.ans raw= 0 w=1 tl_attested _ans TXT drift: sealed=v=ans1; version=v1.0.0; url=https://drift.example.com observed=v=ans1; version=v1.0.0; url=https://malicious-site.com
dnsrecord.ans-badge raw=100 w=1 tl_attested _ans-badge TXT matches sealed value
identity (score 100)
certtype raw=100 w=1 unattested EV certificate; raw 100
solvency (score 0) — no signals in v1
behavior (score 0) — no signals in v1
safety (score 0) — no signals in v1
The drift is real, and the score buries it. agent-006 publishes an _ans record pointing at a host its sealed baseline never named, so dnsrecord.ans scores 0. Six sibling signals at 100 pull integrity up to 86 anyway, past every bar the cascade sets, and the EV certificate puts identity at 100. The result is FIDUCIARY for an agent whose advertised endpoint no longer matches what it sealed. This is the within-dimension dilution from the scoring section, in the case where it matters most.
The score isn't the whole response, though. That drift also emits INTEGRITY_DNS_ANS_DRIFT, which travels in riskFactors right next to recommendedProfile. Read both. The score says how far to trust an agent, the risk codes say what's wrong with it, and a delegation decision needs the two together.
Conclusion
Should your agent hand over the $10,000? On this evidence, no. agent-001 comes back READ_ONLY, which makes it a reasonable choice for a lookup and the wrong choice for a payment. It isn't disqualified, though, and the result says precisely what is missing: a DV certificate is holding identity at 40. Re-register with an EV certificate and the same agent reaches FIDUCIARY, at which point the $10,000 question has a different answer.
ANS answers "is this agent who it claims to be?" Agent Trust Discovery answers "how much can we trust it, and for which actions?" The first question has one correct answer. The second depends on what you're delegating, which is why the output is five dimension scores and a profile label instead of a single number, backed by eight built-in signals across two dimensions.
The engine is configurable: dimension weights are on/off switches, and each signal carries the weight you give it. It's also extensible — solvency, behavior, and safety are declared but empty, and filling one means writing a signal provider with a score function and an explanation string. Agent Trust Discovery is an open source project; there are already active contributors helping to evolve the framework. To learn more, clone the repository and run make demo: agentnameservice/agent-trust-discovery
Agent Trust Discovery implements the Trust Index spec, which is developed in the open as well: agentnameservice/trust-index-spec.
Resources
- Agent Trust Discovery: the open source implementation this post walks through. Clone it and run
make demo. - Trust Index spec: the specification Agent Trust Discovery implements, including the five dimensions and the recommended-profile cascade.
- Agent Name Service organization on GitHub: the ANS reference implementation and SDKs.
- Don’t Trust. Verify. Offline, Sub-Millisecond Agent Verification with ANS: the previous post in this series, on how ANS verifies identity.






