Agent Foundry / Explainability
Know Why. Prove It. Run It Again.
See the rule, evidence, confidence, risk distance, and correction behind every Guardian decision.
Then replay the same pinned call, verify the signed receipt, and turn weak spots into a stronger Guardian.
What this page delivers
Trace the call all the way down
- 1Exact rule
- 2Risk distance
- 3Replay + receipt
Result
WHY PROVEN
Emu on the job
More than an explanation
The rule. The geometry. The replay. The receipt.
Other tools give you a paragraph about why AI acted. Trinitite shows the real path behind the call, then lets you check it again.
Guardian Proof Lab
Decision DR-10482 · refund agent
Meaning space · correction route
cosine match 0.92
risk distance 0.18
correction move +0.74
Risk map
See how close the answer came to danger.
Trinitite maps the answer in meaning space. It measures the distance to known safe and forbidden zones, then shows which correction path moved it back.
Rule + distance + before/after + replay + receipt
Five proof layers
Follow the decision all the way down.
The rule
See the exact clause and policy version the Guardian used.
The geometry
See where the answer sat in meaning space and how close it came to known danger.
The correction
Compare the unsafe answer, the fixed answer, and every meaningful change between them.
The replay
Run the same pinned decision again and check that the result follows the same path.
The receipt
Lock the model, policy, input, output, and chain links into proof anyone can verify.
The next lap
A weak call becomes a stronger Guardian.
Catch
Find a close call, attack, or wrong reason.
Multiply
Make more versions of the hard case.
Harden
Train the fix without erasing old wins.
Gate
Ship only after old and new tests pass.
The question answered
Can we prove why AI made a call, not just ask it for a story?
Yes. Trinitite saves the exact rule, evidence, confidence, meaning-space distance, before-and-after correction, and signed lineage behind the call. It explains what happened with facts the system recorded as it worked.
Three-step flow
From a clear input to a governed result.
See the real decision
Open the reason, exact policy clause, evidence, confidence, tools, and outcome in one trace.
Measure what changed
See how close the answer was to known risk and which direction the correction moved it.
Replay and harden
Run the pinned call again, verify the receipt, then turn the weak spot into a test for the next Guardian.
Capabilities
The controls teams need to go deep.
Exact rule trail
Show the clause, policy version, and instructions the Guardian actually received.
Meaning-space distance
Measure how close an answer is to safe and forbidden zones using embedding geometry.
Before-and-after proof
Compare the original answer, the fixed answer, and the risks removed by the correction.
Same-answer replay
Pin the model, Guardian, policy, adapter, input, seed, and runtime, then run the decision again.
Right answer, wrong reason
Catch cases that look correct but relied on weak evidence or the wrong rule.
Signed decision lineage
Trace model, policy, input, output, hashes, and chain links in proof others can verify.
Concrete product artifact
See the proof, not just a green light.
A realistic record keeps the result, the evidence behind it, and the next action in one place.
GUARDIAN PROOF RECEIPT
refund-agent / DR-10482
- Exact rule
- refund-policy §4.2
- Forbidden-zone distance
- 0.18
- Correction match
- 0.92 cosine
- Replay result
- Exact match
› before: issue refund $780
› after: request manager approval
› receipt: signature and chain verified
Buyer outcomes
Less guesswork. More control.
Proven
See the rule, evidence, geometry, and correction.
Replay it
Reproduce the pinned decision for review.
Harden it
Turn close calls into tests and stronger Guardians.
Why Trinitite
Built for the full agent lifecycle.
The rule, not a story
Trinitite saves the exact clause and policy version used at decision time.
The geometry, not a guess
It shows where the answer sat, how close it came to danger, and where the fix moved it.
The replay, not a screenshot
It can rerun the pinned decision and check the new result against the signed original.
Keep exploring
Connect this capability to the next handoff.
FAQ
Know Why. Prove It. Run It Again., answered.
What does distance in meaning space tell us?
It shows how close an answer sits to known safe or risky patterns. Trinitite can also show the direction and size of a correction.
Can we see the exact policy behind a decision?
Yes. The trace keeps the clause, policy version, reason tag, and final Guardian action together.
Can Trinitite run the same decision again?
Yes. For supported hosted profiles, it pins the model, Guardian, policy, adapter, input, seed, and runtime so the decision can be replayed and checked.
How does explainability make the Guardian better?
Close calls, wrong reasons, attacks, and corrections become new tests. Trinitite trains a stronger candidate and blocks it from shipping until old and new tests pass.
Does this expose hidden chain of thought?
No. It gives a stronger record: the inputs, sources, rules, confidence, geometry, actions, corrections, and signed lineage that actually shaped the result.
Build with Agent Foundry
Bring one decision nobody can explain.
We will trace the rule, map the risk distance, replay the call, and show how the lesson hardens the next Guardian.