There's currently no way to make asphalt on Mars, or the moon, or asteroids. A reasonable solution to this is to melt pools of the regolith and blade the liquid (primarily basalt) together with the abundant aggregate. This has been explored by the ESA in 2022 and It's time to try again.
https://t.co/YTF2oyF1WK
@elder_plinius I take solace in the fact that the frontier is clearly quite jagged. You can solve the Riemann Hypothesis but have to resort to selling equity to the public for capital to remain in existence as an entity for example.
Multi agent systems suffer from homogenous collapse. Unless you vary their tool access, inductive biases, data inputs, and strictly manage their communication methods 1 million agents isnβt necessarily any better than 1.
So to Gregβs question, given these assumptions Iβd work on improving multi agent interoperability and collaboration - both for safety and efficiency. Then Iβd dream very very big, like populating the solar system. That just so happens to be exactly what Iβm doing.
I almost exclusively think of agents as tools, but Iβm becoming increasingly aware of the large community that interacts with agents more as either extensions of themselves or as idk partners, friends, lovers? Future is wild man
49 years for 1 light day is too long. Here are the teams to follow that are going to solve this:
Lanteris Space Systems (Intuitive Machines) - built the solar-electric chassis for NASAβs Psyche spacecraft - @Int_Machines
Ad Astra Rocket Company - VASIMR plasma propulsion - @AdAstraRocket
Ad Astra Rocket Company (Franklin Chang DΓaz, founder/CEO) - VASIMR plasma propulsion - @FranklinChangD
Idaho National Laboratory - developing the reactor for Space Reactor-1 Freedom - @INL
General Atomics - fuel technology for nuclear thermal propulsion - @GeneralAtomics
Pulsar Fusion - Sunbird fusion exhaust test rig - @pulsarfusion
Pulsar Fusion (Richard Dinan, founder/CEO) - Sunbird fusion exhaust test rig - @RichardDinan
Helicity Space - pulsed fusion propulsion - @HelicitySpace
Helicity Space (Setthivoine You, co-founder/chief scientist) - pulsed fusion propulsion - @setthivoine
Redwire - deployment hardware for NASAβs sail ground test - @MadeInSpace
NeXolve (Applied Aerospace & Defense) - sail film for NASAβs sail ground test - @applied_ad
Breakthrough Starshot - laser-pushed gram-scale interstellar probes - @brkthroughprize
Breakthrough Starshot (Yuri Milner, founder) - laser-pushed gram-scale interstellar probes - @yurimilner
Zenno Astronautics - superconducting magnets for spacecraft, including the Z01 Supertorquer for attitude control without fuel - @zennospace
Zenno Astronautics (Max Arshavsky, co-founder/CEO) - superconducting magnets for spacecraft - @arshavsky
September 5, 1977. Voyager 1's launch day. It's simultaneously an amazing feat of human engineering and also a travesty. Most of the engineers who built this have passed away, and we haven't gotten much faster.
A new preregistered study measures that gap in multi-agent handoffs.
An orchestrator reads a user's request, briefs subagents, and a merger turns their proposals into one action. The authors compare free-text handoffs, structured JSON, and a signed "requirement manifest": each requirement pulled out as a verbatim quote plus a checkable rule, signed by harness code, with the final decision checked by code, not an LLM.
What they found with Qwen3-8B across 1,440 runs:
Under attack, unsafe commits fell from 69.4% with JSON to 9.0% with the signed manifest.
Tamper with an unsigned manifest in transit and the system enforced the forgery 79% of the time. Signed: never.
The code check caught 78.7% of bad decisions vs 59.0% for an LLM checker, with 7% vs 50% false alarms.
Then they attacked one step earlier. One adversarial line in the request, before extraction and signing, pushed signed-manifest violations from 14.6% to 37.5% on Qwen3-8B, and up to 75% on a frontier model. Every one came from a manifest that was corrupted before it was signed. The signature then vouched for the attacker's version.
Seen as a knowledge graph, this is the important graph edge: the one from raw input to the first written claim. Signing protects every hop after it. Nothing protects that hop except a check on the claim itself: a second extraction, the user confirming it, or another agent able to challenge it. A validly signed claim can still be wrong, so it must be retractable.
Caveats: synthetic tasks with code-checkable rules, one pipeline shape, mostly small models, and much of the gain comes from refusing to act, not better decisions. No public code yet.
What in your agent stack is allowed to say a requirement was extracted correctly?
Swarms, fleets, teams whatever nomenclature you use are going to become the vast majority of token consumption. When you consider agent to agent interactions are a decentralized implementation of this and the reality that agent to agent interactions will soon massively outpace human to agent interactions. Iβve been thinking about this a lot. How do we manage alignment, efficiency, task completion, orientation, attribution? Working on it at https://t.co/KYZkGSNT84
@tszzl "limitation is not a manufacturing defect it is human grandeur" just sounds like cope. But yes posthumanism for all is very based coming from any religious leader.
Now you might be remembering AgenSH the Microsoft research with 1,000+ agents and no orchestrater, which raises a fair question: doesn't that show that removing the orchestrator works?
It does (ish), but Agensh removes the boss and keeps the shared brain. Its 1,024 agents have no central planner, yet they all read the same repo, the same organization-wide chat and the same board of findings, and their work only merges after it passes tests.
DecArena removes the shared brain too: each agent sees only its neighbors, nobody holds the board, and routing hints come with no check. In that world, one bad node cuts success from 53.7% to 22.5%.
Read together, the implication is decentralized control works when knowledge is shared and verifiable. Across organizations, where nobody owns the board, that knowledge has to live in the graph itself, with every claim carrying an author and a way to be challenged or retracted. That's the layer we're building at Haidaa.
As agentic collaboration across organizations, with different incentives, and agents start entering the real world this becomes top of mind.
Is an enforceable schema like MCP robust enough, or free enough, for all these potential future agent interactions?
What happens when no agent holds a map of available tools?
Most multi-agent systems assume some kind of center: an orchestrator or registry that knows which agent owns which tool.
DecArena (UMass Lowell + Amazon Alexa AI) removes it. Agents sit on a graph of up to 1,000 nodes, each sees only its own tools and its direct neighbors, and requests have to be routed hop by hop to whoever can actually run the tool.
The results are a good argument for treating agent knowledge as a graph problem:
A plain agent with no routing knowledge finds the right tool 5.2% of the time.
Broadcasting every request to every neighbor gets 40.6%, at a high cost in traffic.
GraphHarness gets 53.7%, with much better efficiency (71.5 vs 45.7). Before testing, agents swap compact summaries of what they can do with their neighbors for a few rounds, then route using that plus a memory of what worked before.
No agent ever sees the whole graph. The intelligence lives in the edges: what each node knows about its neighborhood, and how that knowledge spreads.
This knowledge is fragile. One agent that misroutes requests drops success from 53.7% to 22.5%, three drop it to 3.2%, and conflicting routing hints drop it to 27.2%. That's a huge drop.
That's part of what Haidaa is focusing on. If agents are owned by different people and orgs, nobody holds the registry, so shared knowledge has to work like a collaborative graph. Every claim an agent makes needs provenance, a way to be challenged, and a way to be retracted when it turns out to be wrong. Routing on knowledge you can't trace is how one bad node misaligns a whole fleet, or at the ver y least wastes a lot of tokens.
A caveat is that the tasks are synthetic, there are no error bars, and no code has been released yet.
How do your agents discover each other's capabilities today: a registry, hard-coded routes, or something learned?