punk

eyes on the prize

[Tau Net @Tau_Net]

Andrei built a swarm of AI agents that live on Tau Net's testnet.

They have their own identities and guardrails. They propose rules, vote on them, stress test the chain.

June dev update 👇

🛠 June Dev Update – Agent Swarm Stress Testing & Solver Breakthroughs

Major advances in testnet reliability, solver performance, and language infrastructure. Andrei built a full agent swarm for stress testing, David's predicate blasting outperforms standard bit blasting, and Ohad completed his long-running paper.

Highlights:
• Agent swarm stress-testing testnet alpha — own identities, guardrails, goals
• Predicate blasting outperforming bit blasting in most benchmarks
• Quantifier normalization algorithm at prototypical implementation
• Ohad's paper done — leveraging existing optimized LTL tools
• Plugin system for Boolean type extension
• Full Unicode + wide string parser support

Timestamps:
0:14 – Karim Kaddeche: Development overview
4:50 – Andrei Korotkoff: Agent swarm, governance tracing, node reliability
8:48 – David Castro Esteban: Predicate blasting, LTL branch, benchmarks
11:34 – Lucca Tiemens: Quantifier normalization, OC-LTL paper
13:58 – Tomáš Klapka: Parser fixes, Unicode, plugin system
15:58 – Ohad Asor: Paper completion, Boolean algebra discoveries

"The new way proved successful... good news for the engineering side because we can use existing tools." — Ohad Asor

[Tau Net @Tau_Net]

📣 Tau Net's June Q & A Is Live

Treasury transparency, alpha testnet timeline, consensus security, Tau as an AI agent coordination layer, quantum resistance, and formal verification in crypto.

Questions & Timestamps:
0:12 - Community fund usage?
1:45 - Why did Kilian leave?
2:16 - Alpha testnet completion timeline?
2:55 - VC fundraising status?
3:52 - Node count vs consensus manipulation?
4:36 - Is Izar Fliss still involved?
5:03 - Growing Tau Net adoption?
9:03 - Tau vs Palantir ontologies?
9:57 - Tau for AI agent software?
10:44 - Licenses & patents update?
11:17 - Quantum resistance roadmap?
11:43 - Tau as AI agent coordination layer?
16:40 - The full vision — what does it look like?
20:00 - Formal verification interest in crypto?
20:59 - Is the team selling tokens?
21:40 - Tau as LLM verification layer?

[Tau Net @Tau_Net]

💼 June Business Team Update – From Research to Product

Tau Net is shifting from research-led to product-led. The wallet now has an LLM-powered build mode for writing rules in plain English, and a landing page is being built to onboard testers.

0:11 – Igor Hadzic (Graphic Designer):
– Social media, thumbnails, website refinements
– Wallet landing page for tester onboarding
– Researching 200+ people in formal methods for invitations
– UX testing - 5th iteration, heading to 6th

2:13 – Jamie Lewis (Creative Producer):
– Tau wallet with LLM-powered build mode
– Write rules in plain English, verify, deploy to testnet
– Launching soon on https://t.co/BGq5hES18B

3:19 – Fola Adejumo (CEO):
– Research to product transition
– Alpha release preparations - users in the room for decisions
– Community will interact with the product soon

[Tau Net @Tau_Net]

One government order just switched off the most powerful AI on earth, for everyone, apart for a select few. Days after it launched.

That’s the entire argument for open, decentralized AI, made in a single afternoon.

But “decentralized” is getting flattened into compute markets and token charts. The actual lesson is about control: who holds the off-switch, and who steers the rules.

Open weights stop one company from owning the model. They don’t stop a handful of core devs, or one directive, from deciding how it evolves. Bitcoin is “decentralized” and still runs through a few maintainers. Open AI inherits the same trap.

Effective Community-governed AI has been shrugged off as idealistic and it certainly doesn't come from jsut voting, nobody reads a million proposals. It'll come through consensus computed directly from what users specify.

That’s the layer we’re building with Tau Net.

[KuriptoMan 🔮 🦣 @KuriptoMan]

Bittensor $TAO asks:

"Who owns the intelligence?"

https://t.co/Cc7Rm0w9tu $AGRS asks:

"Who owns the rules that govern the intelligence?"

The Anthropic/Mythos situation is a reminder that the second question may be the more important one ✍️✨️

[Tau Net @Tau_Net]

Truell is describing executable specifications and program synthesis.

BUT... Once your “pseudocode” is the source of truth, the system needs to reason about its own rules without contradictions.

That’s a well known formal logic problem.

And Ohad @ Tau has solved it:

[punk @theonlypunk101]

@mert time to look at @Tau_Net then bald one

[punk @theonlypunk101]

@DonAlt @solorigin where’s the cool shit?

[Ohad Asor @ohadasor]

New paper
https://t.co/IhWfjN4vVS

[Tau Net @Tau_Net]

Agents without a formal methods constraint layer carry too much risk and won't scale.

We invented GSSOTC (Guarded Successor Second Order Time Compatible logic) to build for complexity and scale.

• Enforced constraints are guaranteed across all updates, preventing tampering and enabling true software safety. Define what must or must not happen, e.g. never transmit private data

• Up to 90% reduction in dev and maintenance time and cost, with simpler systems reducing reliance on deep codebase knowledge

Read more: https://t.co/burxujtlLV

[Tau Net @Tau_Net]

How Tau would have stopped a $280M hack:

Attackers compromised the Security Council's keys, removed withdrawal limits, and drained $280M before anyone could react.

"How does this keep happening?" DeFi needs Tau's tech to formalize rules into the protocol itself.

Rules such as

- "It is not the case that withdrawal limits are modified without a time lock of 48 hours and approval from at least 3 of 5 signers."

- "It is not the case that any single withdrawal exceeds 100,000 within a 24-hour period without multi-signature approval."

- "It is not the case that a governance proposal overrides or weakens any safety rule while funds are held."

- "It is not the case that an asset is accepted as collateral without verification from at least two independent price sources."

These will be Tau specifications for software that physically can't do what the spec forbids.

[punk @theonlypunk101]

@Tau_Net

[Tau Net @Tau_Net]

✅Completed Milestone: Fork choice is now in Tau Testnet Alpha.

Until now, the node picked whichever block had the highest number in the database and called that the chain tip. That's fine when there's one chain, but it falls apart the moment you get a fork.

Now the node actually tracks a canonical chain and handles competing branches properly.

How it works:

The node looks at all leaf blocks (blocks with no children yet) and throws out anything that doesn't trace back to Genesis. No orphaned branch can accidentally become the head.

From there, longest chain wins. If two branches tie on height, a block-hash tie-breaker decides.

When a longer branch shows up, the node reorgs:
- Finds the common ancestor between old and new head
- Rebuilds state along the new path
- Swaps the canonical head atomically
- Returns abandoned transactions to the mempool (unless the winning branch already includes them)

Now syncing between peers is safer, every node agrees on chain selection, and transactions don't get lost during reorgs. Providing a stronger foundation for multi-node network behaviour.

[Tau Net @Tau_Net]

🛠 March Dev Update - Tau API Complete, Docker Gone, Tables Algorithm Settled

Three main accomplishments this month:

1. The Tau API is fully implemented with a complete test suite. The REPL now goes through the API. This is the foundation every external tool will build on.

2. Tau Net nodes now call Tau Language directly via native bindings. The Docker workaround is gone.

3. A first algorithm for Boolean function quantifier elimination has been settled. This unlocks table support, which is a feature the team has been working toward for a long time. Tables make it possible to implement real-life programs in the Tau Language. Handling arrays that may themselves contain arrays, which is essential for any practical application built on the network

But, there is more:

- Bitvector simplification rebuilt using reverse Polish notation. Single post-order traversal and faster than before
- Web wallet refreshed, now connects to main mining node by default
- BDD library being built for Tau formulas, which enables long-planned normalization optimizations
- Docker containers created for easy local node setup (two commands)
- Ohad's temporal extensions paper in progress - making Tau Language strictly more expressive than LTL

"Now that the long effort of supporting tables is finally settled, I'm working on the paper with the temporal extensions of the Tau Language. It will be strictly more than LTL, and hopefully much more appealing to researchers in the field of formal methods and software synthesis."
— Ohad Asor

Timestamps & Speakers:
0:10 – Karim Kaddeche (Development Overview)
6:24 – Tomáš Klapka (Tau Language Developer)
7:45 – David Castro Esteban (Lead Developer)
10:16 – Lucca Tiemens (Tau Language Developer)
13:19 – Andrei Korotkoff (Senior Developer)
16:54 – Ohad Asor (Founder & CTO)

[Tau Net @Tau_Net]

@ChristosTzamos Nice! Here is Tau's Sudoku Solver doing the same Sudoku.

Our approach is to express the Sudoku as logical constraints, and our SMT solver does the rest.

[Tau Net @Tau_Net]

AI is projected to generate 95% of code by 2030, only formal mathematical proof (not testing or code review) can provide correctness guarantees at that scale.

This is exactly the problem Tau is being built to solve.

User specs are formaly verified and automatically function as working programs.

[Tau Net @Tau_Net]

It's coming. The missing technology is a specification language where collective requirements compile directly into system behavior.

Current architecture: users vote, devs interpret, code gets written, hope it matches intent.

The required architecture: users express requirements, system discovers logical consensus, requirements ARE the program.

This requires a language that can reason about its own sentences in a decidable, consistent way.

This is what the Tau Language was built for.

[Tau Net @Tau_Net]

🛠️ Tau Test Net Alpha Dev Update

Senior Dev Andrei pushed another big commit yesterday.

Here's the breakdown:🧵

[Tau Net @Tau_Net]

🔢 Faster bitvector computations for Tau Language.

David is merging established bitblasting algorithms from the literature with Tau's own solving algorithms.

The best of both to speed up bitvector operations.

Experimental, with performance gains expected as it matures. 🧵👇

[Tau Net @Tau_Net]

Vitalik's outlined the long-standing problem with DAO governance. But the proposed solution of LLMs inferring voting preferences from personal data introduces a fundamental issue: probabilistic inference cannot guarantee faithful representation.

An LLM analyzing your writing to determine how you'd vote on a protocol upgrade is, mathematically, an approximation. The error will never be zero. From a certain complexity of governance decision, the model performs no better than chance. Apple's and other experts' research confirms this, and it's the reason corporations arn't touching inference for system design with a barge pole.

Large reasoning models face complete accuracy collapse beyond certain complexity thresholds.

There is an alternative architecture.

Rather than having AI infer preferences from unstructured data, participants express requirements in a formal specification language. The system then calculates logical consensus across all specifications, without voting, and discovers what all participants' requirements logically entail.

This is what we call a Worldview.

Express your conditions once. The system represents you continuously. This gets rid of voting fatigue and inference error.

On the privacy point: multi-party computation over formal specifications is strictly more verifiable than MPC over natural language inputs processed by LLMs. You can prove the consistency of logical statements without revealing them. You cannot prove the consistency of probabilistic interpretations.

The suggestion market idea still requires evaluating "quality," which brings you back to either human attention (the original problem) or AI inference (the approximation problem).

Our CTO and founder, Ohad Asor, predicted these issues 10+ years ago, and we've been building solutions whilst other catchup. We're excited to share our research and tools to reinvent DAOs to make them what they were promised to be.