The physics is this: any system that delegates through hops, without a machine-readable contract, will decay intent. The substrate does not matter. The decay rate changes. The mechanism is always the same.
An orchestrator issues a task to a sub-agent with a clear constraint: the result must satisfy condition X. The constraint is expressed in the task prompt as prose — a sentence, maybe two.
The sub-agent re-summarizes the task for the next hop. The re-summarization preserves the goal and drops the constraint — not maliciously, but because no mechanism existed to mark it as load-bearing. Natural language is lossy. Each re-summary is a compression. Compressions drop things.
By hop three, the constraint does not exist. The task completes. The constraint is violated. The orchestrator has no way to see this, because the constraint was never in anything propagatable. It lived in prose. Prose does not travel intact.
The PACT-AX fix is direct:
from pact_ax.primitives.trust_context import TrustIntent, TrustConstraint
intent = TrustIntent(
purpose="run analysis on dataset",
constraints=[
TrustConstraint(
key="exclude_invalid_records",
description="Records failing validation must not appear in output",
load_bearing=True, # must survive every hop verbatim
),
],
)
The constraint is now machine-readable, propagatable, and verifiable at every hop:
# At any downstream agent — before acting
violations = child.verify_intent_integrity(parent_intent)
if violations:
child.signal_break(
"intent_integrity",
f"load-bearing constraints dropped: {violations}",
)
If the constraint is dropped at any hop, it is detectable. The downstream agent does not need access to the original orchestrator — the contract travels with the context.
A message is drafted with a specific framing: a clear ask, a specific angle, a constraint on how the request should be understood. It is sent. Someone forwards it. The forward drops the framing — not deliberately, but because forwarding is a compression. The recipient replies to the re-summarized version. The reply misses the point.
The mechanism is identical. Natural language delegation chain. No load-bearing flag. No way for any hop to distinguish “this is the core of the request” from “this is context I can drop.” The goal survives (there is a request). The constraints decay (the specific framing is gone).
The fix does not exist yet in human outreach infrastructure. That is the point.
A long session begins with a clear constraint: “we are operating within these boundaries, do not suggest X.” Forty turns later, the agent’s context has been compressed and reweighted. The constraint from turn one has been treated as background. The agent suggests X.
It did not forget. It re-summarized, and the re-summarization was lossy. The constraint was not marked as load-bearing — it was expressed in natural language at turn one, and natural language at turn one does not survive forty turns of context compression intact.
The same physics. The same mechanism. A different substrate.
Three substrates. One failure mode.
The common cause: intent expressed as prose travels through a compression function at every hop. The compression preserves goal and degrades constraints. The goal is always the most salient thing; constraints are context, and context is what compression sacrifices first.
The invariant is not “systems lose intent.” It is more specific: load-bearing constraints decay faster than goals, because goals are compression-stable and constraints are not.
The fix is not “write clearer prose.” That addresses the input, not the compression function. The fix is to remove the compression function from the path of load-bearing constraints — express them in a form that does not pass through re-summarization at all.
That is what TrustConstraint(load_bearing=True) does. A machine-readable contract does not
go through the compression function. It propagates intact or it raises a detectable violation.
Prose is lossy. Contracts propagate.
If intent decay were specific to AI agents, it would be an AI safety concern — interesting but bounded. If it appears across human outreach, agent chains, and human–AI collaboration with the same mechanism, it is something else: a fundamental property of natural-language delegation systems.
AI agents did not introduce intent decay. They made it visible, faster, and at scale. They also — for the first time — make the fix tractable: machine-readable contracts that travel with the delegation, not inside it.
The infrastructure we are building for agent trust is also, precisely, the infrastructure that was missing from every other natural-language delegation system. That is not a feature. That is what it means for a solution to address the root cause.
Part of the PACT-AX doctrine series — neurobloom.ai
Code: github.com/neurobloomai/pact-ax
Current orchestrator/subagent patterns feel strong. They are strong. Claude Code, LangGraph, CrewAI, AutoGen — the real-world experience of building with these is that things generally work, agents generally stay aligned, handoffs generally preserve intent.
The question worth asking: why does it work? Because the answer determines where it stops.
Look at what every working production agent network has in common:
Subagents cannot talk to each other. All communication routes through the orchestrator.
Nothing persists beyond the task. Each invocation starts fresh; there is no durable agent identity.
Everything routes through one synthesizer audited by one human. The human is the root.
Trust is never encoded in these systems. It is implied by the shape of the wiring. The star topology is doing what a trust layer would do — but by construction, not by design. The human at the root is manually re-injecting lost intent at every checkpoint. That is what HITL actually is: a human being the error-correction mechanism for intent decay the system has no other way to handle.
This is not a criticism. It works. But it means the safety guarantee is load-bearing on one constraint: a single human’s working memory can encompass the entire delegation graph.
Before MCP, trust was implicit in lineage. Same codebase. Same company. Same deployment. Same model vendor. If an agent did something unexpected, you had one place to look and one team to call. The implicit trust guarantee was: we control everything in the chain.
MCP standardized connection. Any model can now call any tool from any vendor. Any agent can route to any other agent across org boundaries. The ecosystem is moving toward persistent agents — agents with durable identity, cross-session memory, multi-org presence.
This is the right direction. It is also the moment the star topology’s implicit guarantee dissolves.
When a sub-agent comes from a different vendor, a different session, a different org — there is no shared lineage. No shared human root. No single synthesizer the conversation routes through. The human can no longer hold the full delegation graph in working memory, because the delegation graph now crosses boundaries the human cannot audit.
MCP standardized connection. Nothing standardizes whether the connected party should still be listened to.
The current answer to this is authentication: signed credentials, OAuth scopes, API keys. Token delegation. A binary check at initialization.
That answers a different question.
Token says: this agent was authorized at T=0.
The question is: is this agent still aligned at T=now?
Authorization is a snapshot. Trust is duration. The industry is building snapshots and calling them trust infrastructure.
This is not a gap nobody has noticed — it is a gap nobody has named, because in star topologies it never surfaces. The star suppresses the symptom. Every agent in the chain was issued by the same orchestrator, audited by the same human, fresh-started for this task. Of course it stays aligned. It has no opportunity not to.
The symptom appears at the star→mesh transition. Persistent agents. Cross-org delegation. Multi-session context. Agents that outlive the task that created them. At that point, the question “are you still trustworthy?” has no answer in any current framework.
TrustAlignmentCheck is a continuous n/n gate — not a T=0 snapshot. You declare the
dimensions you care about (behavioral consistency, mode of engagement, capability coherence,
whatever the collaboration requires). The engine evaluates them. If one drifts, the gate
fails. The context marks itself as requiring a re-gate.
TrustContext is an intent-preservation contract. Not just “you’re permitted to act” but
“here is the purpose and the load-bearing constraints on this delegation.” It propagates
through every hop. Sub-agents can verify that the intent they received matches the intent
that was issued. Omissions are detectable. Modifications are detectable.
TrustIntent is the answer to the MASI-class failure: a constraint that lived in the
delegator’s head — “delisted tickers invalidate the scan” — but had no propagatable form.
Prose is lossy. Contracts propagate.
None of this requires replacing star topologies. It is additive to them. What it does is make the implicit guarantee of the star topology explicit — so it survives the moment the star topology doesn’t.
The star is doing PACT’s job by brute force. One human, working memory as the trust substrate, fresh-start disposable subagents. This is a correct and effective strategy at current scale.
The industry roadmap is a march toward the point where it stops. Persistent agents. Cross-org sessions. MCP-connected meshes. Every step in that direction is a step away from the conditions under which the star topology’s implicit trust guarantee holds.
PACT-AX is not a replacement for what works today. It is the substrate that makes what works today survive tomorrow’s topology.
Part of the PACT-AX doctrine series — neurobloom.ai
Code: github.com/neurobloomai/pact-ax
You’re having a conversation with an AI agent. You ask it to help you plan a project. It gives you a brilliant answer. Ten minutes later, you ask a follow-up question. The agent responds perfectly… but something feels off. It’s coherent, but it doesn’t quite connect to what you discussed before.
The conversation is technically continuous, but experientially fragmented.
This is the gap in modern AI agents: they respond, but they don’t relate.
Current AI agents have memory, sure. They can recall what you said. They can store facts in vector databases. They can retrieve context. But here’s what they can’t do: they can’t maintain a continuous sense of who they are in relation to who you are across time.
It’s like talking to someone with perfect recall but no sense of narrative. They remember the words, but they’ve lost the thread of the story.
Most AI systems try to simulate coherence:
This works. Sort of. But it’s brittle.
What if instead, we could make agents embody coherence?
Not by storing more data, but by maintaining a living story of the interaction. Not by retrieving better, but by carrying forward an evolving understanding of the relationship.
The difference is subtle but profound:
Here’s the core idea:
What if an agent maintained a “story” of its interaction with you that evolves with every exchange?
Not a chat log. Not a summary. A story — with:
Without Story Keeper:
User: "Help me plan a startup"
Agent: [Gives generic startup advice]
[10 messages later]
User: "What about funding?"
Agent: [Gives funding advice, vaguely connected to earlier context]
With Story Keeper:
User: "Help me plan a startup"
Agent: [Advice + creates story: "Entrepreneur at ideation stage, values clarity"]
[10 messages later]
User: "What about funding?"
Agent: [Funding advice grounded in the evolving story of this specific entrepreneur's journey]
The agent doesn’t just remember you talked about a startup. It carries forward an evolving understanding of your entrepreneurial journey.
The magic happens in three pieces:
story_state = {
"characters": {
"user": "Entrepreneur at ideation stage, values clarity over complexity",
"agent": "Strategic advisor focused on practical next steps"
},
"arc": "Beginning: Exploring startup concept → Current: Validating core assumptions",
"themes": ["clarity", "practical action", "managing uncertainty"],
"last_beat": "User expressed concern about market timing",
"context": "Week 2 of entrepreneurial planning journey"
}
After each interaction:
Before each response:
For Users:
For Developers:
This isn’t just theory. We’ve built a working prototype called Story Keeper — ~200 lines of Python that demonstrates the concept: an agent that maintains narrative continuity, conversations that build on themselves naturally, coherence through story, not just memory.
Part of the Agent Evolution series — neurobloom.ai
]]>