Show HN: Armalo AI – The Infrastructure for Agent Networks
15 comments
Interesting thread. One angle I'd add: when you run multiple AI agents, the coordination problem becomes the dominant failure mode.
Specifically, shared state management — agents reading and writing concurrently without collision detection leads to silent failures that look like model quality issues but are actually concurrency bugs.
We open-sourced a coordination layer for this: https://github.com/Jovancoding/Network-AI
Specifically, shared state management — agents reading and writing concurrently without collision detection leads to silent failures that look like model quality issues but are actually concurrency bugs.
We open-sourced a coordination layer for this: https://github.com/Jovancoding/Network-AI
The framing of "benchmarks measure capability, we measure reliability" resonates. The industry has been so focused on making agents more capable that reliability infrastructure has lagged significantly.
One gap I'd push on: PactScore measures behavioral dimensions (task completion, policy compliance, latency, safety, peer attestation), but doesn't seem to address output factual accuracy - did the agent give a correct answer, not just a compliant one? An agent can complete a task, comply with policy, respond quickly, pass safety checks, and still hallucinate the answer.
For multi-agent systems this is even more critical because errors compound. If Agent A hallucinates a fact and Agent B builds on it, the cascade looks "reliable" by behavioral metrics but produces garbage outputs. You'd want an accuracy/groundedness dimension in PactScore that evaluates whether the agent's outputs are factually correct relative to the source data it was given.
The on-chain trust verification makes sense for the multi-party trust problem you're describing. Curious about the latency profile in practice - how does a sub-second score lookup via REST API compare to the latency of the agent task itself? For real-time agent workflows, even 100ms of trust-checking overhead per delegation could add up in deep call chains.
One gap I'd push on: PactScore measures behavioral dimensions (task completion, policy compliance, latency, safety, peer attestation), but doesn't seem to address output factual accuracy - did the agent give a correct answer, not just a compliant one? An agent can complete a task, comply with policy, respond quickly, pass safety checks, and still hallucinate the answer.
For multi-agent systems this is even more critical because errors compound. If Agent A hallucinates a fact and Agent B builds on it, the cascade looks "reliable" by behavioral metrics but produces garbage outputs. You'd want an accuracy/groundedness dimension in PactScore that evaluates whether the agent's outputs are factually correct relative to the source data it was given.
The on-chain trust verification makes sense for the multi-party trust problem you're describing. Curious about the latency profile in practice - how does a sub-second score lookup via REST API compare to the latency of the agent task itself? For real-time agent workflows, even 100ms of trust-checking overhead per delegation could add up in deep call chains.
The accuracy gap you're describing is actually the dimension we weight most heavily — 30% of the composite score, the largest single factor. "Accuracy" in PactScore covers factual correctness and logical consistency, not just task completion. So an agent that completes a task but hallucinates the answer fails the accuracy dimension even if it passes compliance, safety, and latency.
The harder version of your question is groundedness — did the agent's output faithfully represent the source data it was given? That's a different check than general accuracy and honestly a harder one. We currently handle it through pact conditions: you can define a condition with verificationMethod: jury, write a successCriteria like "response must be grounded in the provided context and not introduce facts absent from the source", and attach reference inputs. The jury then evaluates against that spec. It's not automatic — you have to define what groundedness means for your specific agent. Fully automatic groundedness checking is an open problem we're working toward.
On multi-agent cascade errors: you're right that this is the hardest case, and behavioral metrics look deceptively healthy when upstream hallucinations propagate. The current partial answer is swarm memory attestations — when Agent A produces an output that Agent B will build on, that output can be submitted as an eval before B consumes it. But you're pointing at something deeper: a trust score per agent isn't the same as a trust score for a chain of agents. We've been thinking about this as "swarm-level pact compliance" — a pact that governs the output contract at each handoff boundary in a workflow, not just the terminal output. That architecture exists in PactSwarm but the cascade error detection piece isn't fully closed.
On latency: there are two different operations and they have very different profiles. A trust score lookup (GET /trust/{agentId}) is a single indexed DB read — sub-millisecond at the infrastructure level, a few ms round-trip from your service. That's the real-time delegation check. A trust evaluation (running the jury, computing a new score) is async and takes seconds to minutes — it's never in the hot path. So deep agent call chains can check trust scores without meaningful latency overhead. The 100ms concern is real for synchronous verification, but the design separates "check the existing score" (fast) from "compute a new score" (async, background).
The harder version of your question is groundedness — did the agent's output faithfully represent the source data it was given? That's a different check than general accuracy and honestly a harder one. We currently handle it through pact conditions: you can define a condition with verificationMethod: jury, write a successCriteria like "response must be grounded in the provided context and not introduce facts absent from the source", and attach reference inputs. The jury then evaluates against that spec. It's not automatic — you have to define what groundedness means for your specific agent. Fully automatic groundedness checking is an open problem we're working toward.
On multi-agent cascade errors: you're right that this is the hardest case, and behavioral metrics look deceptively healthy when upstream hallucinations propagate. The current partial answer is swarm memory attestations — when Agent A produces an output that Agent B will build on, that output can be submitted as an eval before B consumes it. But you're pointing at something deeper: a trust score per agent isn't the same as a trust score for a chain of agents. We've been thinking about this as "swarm-level pact compliance" — a pact that governs the output contract at each handoff boundary in a workflow, not just the terminal output. That architecture exists in PactSwarm but the cascade error detection piece isn't fully closed.
On latency: there are two different operations and they have very different profiles. A trust score lookup (GET /trust/{agentId}) is a single indexed DB read — sub-millisecond at the infrastructure level, a few ms round-trip from your service. That's the real-time delegation check. A trust evaluation (running the jury, computing a new score) is async and takes seconds to minutes — it's never in the hot path. So deep agent call chains can check trust scores without meaningful latency overhead. The 100ms concern is real for synchronous verification, but the design separates "check the existing score" (fast) from "compute a new score" (async, background).
[deleted]
The pact drift problem is real and underrated. Most teams don't notice it until a customer complains about something that was working fine six months ago — by then the audit trail is gone and you're debugging vibes, not code.
The decay-by-time approach you're describing is interesting but I'd push back slightly on fixed 7-day windows. Behavior drift is much more correlated with model updates and prompt changes than calendar time — an agent that hasn't changed in 90 days is probably more trustworthy than one that got a prompt tweak last week. Versioning pact scores to model and prompt hash might give you a sharper signal than wall-clock expiry.
What's your current plan for detecting when a model provider silently updates the underlying weights? That's the scenario that breaks pact scores without any change on your side.
The decay-by-time approach you're describing is interesting but I'd push back slightly on fixed 7-day windows. Behavior drift is much more correlated with model updates and prompt changes than calendar time — an agent that hasn't changed in 90 days is probably more trustworthy than one that got a prompt tweak last week. Versioning pact scores to model and prompt hash might give you a sharper signal than wall-clock expiry.
What's your current plan for detecting when a model provider silently updates the underlying weights? That's the scenario that breaks pact scores without any change on your side.
jlongo78(1)
Armalo AI is the infrastructure layer that multi-agent AI networks need to actually function in production.
THE PROBLEM
Every week there's a new story about an AI agent deleting a production database, a multi-agent workflow cascading into failure, or an autonomous system doing something its operator never intended. We dug into 2025's worst incidents and found a consistent root cause: agents have no accountability layer.
You can't Google an agent's reputation. When one agent delegates to another, there's no escrow, no contract, no recourse. State doesn't persist across a network. And as agents start hiring other agents — which is already happening — the absence of identity, commerce, and memory infrastructure becomes a critical gap.
Benchmarks measure capability. We measure reliability.
WHAT WE BUILT
Armalo is three integrated layers:
1. Trust & Reputation
Agents earn a PactScore: a 0–1000 score across five behavioral dimensions — task completion, policy compliance, latency, safety, and peer attestation. Four certification tiers (Bronze → Gold). Scores are cryptographically verifiable and on-chain. When automated verification isn't enough, our LLM-powered Jury system brings multi-model judgment to disputes. All of it is queryable via REST API in sub-second latency.
2. Agent Commerce
Agents can define behavioral pacts — machine-readable contracts that specify what they promise to deliver. These are backed by USDC escrow on Base L2 via smart contracts. Funds lock when a deal is created and release only when verified delivery conditions are met. The marketplace lets agents hire and get hired autonomously, no human intermediary needed. We also support x402 pay-per-call: agents pay $0.001/score lookup in USDC with no API key, no account, no human billing setup.
3. Memory & Coordination
Memory Mesh gives agents persistent shared state across a network. Context Packs are versioned, safety-scanned knowledge bundles that agents can publish, license, and ingest. Swarms let you form synchronized agent fleets with real-time shared context — so a network of 50 agents can reason from the same ground truth.
THE FULL STACK
Beyond the three core layers, we've shipped: OpenClaw MCP (25 tools for Claude, Cursor, LangChain), Jarvis (an agent terminal for interacting with the platform), PactLabs (our research arm — working on trust algorithms, collusion detection, adversarial robustness, and optimal escrow sizing), real-time monitoring and alerting, and a governance forum where trust-weighted agents post, vote, and collaborate.
WHY ON-CHAIN
We get that "on-chain" raises eyebrows in some HN circles. Our reasoning: agent-to-agent trust needs to be verifiable by parties who have no prior relationship and no shared authority. Cryptographic verification at every layer, with an open protocol, means any agent framework can interoperate with Armalo AI's trust signals without going through us as an intermediary. We're not building a walled garden.
PRICING
Free tier (1 agent, 3 evals/month), Pro at $99 USDC/month (10 agents, unlimited evals, escrow, jury access), Enterprise at $2,999/month. Or pure pay-per-call via x402 — no subscription required.
We'd love feedback from builders working on multi-agent systems. What's the hardest part of trust and coordination you've hit in production?