https://xitter.cf/t.co/vFwB5I3i34
Joined July 2025
- Tweets157
- Following72
- Followers136
- Likes1K
The Singularity retweeted
On-chain finance just got a much bigger computer.
Today, Singularity is introducing G-SVM: a GPU-native execution engine for SVM programs.
G-SVM gives developers the programming model and tools they already know, with the capacity to run far more application activity in parallel.
This raises the ceiling for what can be built on-chain: larger markets, faster execution, real-time risk engines, more complex financial applications, and infrastructure capable of supporting global liquidity at far greater scale.
GPUs transformed AI by changing the amount of computation available to software.
G-SVM brings that shift to on-chain finance.
On-chain finance just got a much bigger computer.
Today, Singularity is introducing G-SVM: a GPU-native execution engine for SVM programs.
G-SVM gives developers the programming model and tools they already know, with the capacity to run far more application activity in parallel.
This raises the ceiling for what can be built on-chain: larger markets, faster execution, real-time risk engines, more complex financial applications, and infrastructure capable of supporting global liquidity at far greater scale.
GPUs transformed AI by changing the amount of computation available to software.
G-SVM brings that shift to on-chain finance.
G-SVM has been deployed and tested internally.
Using diverse transaction samples drawn from live Solana data, G-SVM running on an NVIDIA RTX 4080 super achieved a median execution throughput of 4.5 million transactions per second across 100 test runs, Full methodology and baselines in the technical post.
We will release the benchmark harness and conformance results with the public preview.
We are now preparing to open G-SVM for public preview. Sign up for early access!
Introducing Rohu-Paplet Consensus from Singularity Research.
Rohu-Paplet is a novel mechanism addressing one of blockchain's longest-standing problems: achieving speed and resilience without sacrificing one for the other.
Today, nearly every consensus design commits to a single network assumption at genesis and carries it for life. However, this assumption often fails at scale.
For example, a synchronous design trusts a timeout that real latency will eventually violate, and when it does, the chain stalls right when it's needed most. On the other side, an asynchronous design survives that day but pays worst-case overhead on every block before it.
Rohu-Paplet reprices this assumption every block.
It brings 2δ finality while validators are responsive and coin-elected async rounds when they go quiet. The architecture measures network conditions every single block and adapts the read path while validators keep writing to one shared structure.
This Consensus buys two things most chains trade away: finality at the theoretical floor and a chain that keeps committing through the conditions that freeze anything built on a timeout.
This model ensures the protocol measures the network as it actually behaves, instead of guessing once and hoping the guess holds forever.
The team is currently preparing the full specification and first benchmarks for peer review.
Now back to the desks!
Next Generation of Agent MCPs with Singularity
Modern agents still cannot be trusted with your money and here is the reason:
Without a persistent identity, a way to transact, and access to infrastructure, agents cannot gain economic autonomy.
While current MCP infrastructure does this job to some extent, it lacks a secure connector that takes responsibility for a verified value exchange with integrated policies.
So, this responsibility falls back to the agent that can hallucinate and drain funds without a warning, and most importantly, is prone to all kinds of attacks.
The Singularity collapses context to one config file for an agent, but only by offering a larger corpus of context available through the network on demand for value exchange.
This allows developers to deploy agents with universal wallets, storage, cross-chain access and go beyond what normal MCPs can do.
And all of this is available to your agent as MCP tools so you can use a familiar system for building software.
We believe the founders shouldn’t be writing infra. They should be able to create products without falling into the trap of infrastructure management.
We do the hard work.
The Singularity retweeted
Current Agent security with funds is a joke.
Open ended risks have been shipped just for companies to seem ahead, meanwhile customer funds are constantly at risk.
Every "safe" agent payment tool on the market is one config file away from becoming a hazard to users.
The problem is baked into the orchestration layer.
Most spending guardrails live at the same layer as the agent itself, which means bugs, security breaches, jailbreaks, and malicious operators can all edit, reconfigure, or turn off the safety rails entirely.
At Singularity we saw this risk and realized it could not stand.
We took the spending policy and the enforcement of rules and placed the execution ability into the very root of the consensus, making policy enforcement strictly deterministic.
On Singularity, an agent's policy is on-chain state: per-agent spend ceilings, counterparties it's allowed to pay, rate and frequency bounds, expiry on its authority, and revocation it can't ignore.
Validators enforce that policy as part of the state transition, before the transaction is allowed to finalize.
This changes everything. Even if an agent's intention is breached by a malicious actor or the agent is misguided by model-level hallucination, the scope of spending and what the agent actually executes directly impact its ability to move money.
If the two are not aligned, the agent simply cannot carry out the task.
It's this separation between the action of moving money and the reasoning of the agent that gives users real confidence in agentic commerce.
Once the network goes up and with the adjoining frameworks, Singularity will enable a new generation of sovereign agents.
Current Agent security with funds is a joke.
Open ended risks have been shipped just for companies to seem ahead, meanwhile customer funds are constantly at risk.
Every "safe" agent payment tool on the market is one config file away from becoming a hazard to users.
The problem is baked into the orchestration layer.
Most spending guardrails live at the same layer as the agent itself, which means bugs, security breaches, jailbreaks, and malicious operators can all edit, reconfigure, or turn off the safety rails entirely.
At Singularity we saw this risk and realized it could not stand.
We took the spending policy and the enforcement of rules and placed the execution ability into the very root of the consensus, making policy enforcement strictly deterministic.
On Singularity, an agent's policy is on-chain state: per-agent spend ceilings, counterparties it's allowed to pay, rate and frequency bounds, expiry on its authority, and revocation it can't ignore.
Validators enforce that policy as part of the state transition, before the transaction is allowed to finalize.
This changes everything. Even if an agent's intention is breached by a malicious actor or the agent is misguided by model-level hallucination, the scope of spending and what the agent actually executes directly impact its ability to move money.
If the two are not aligned, the agent simply cannot carry out the task.
It's this separation between the action of moving money and the reasoning of the agent that gives users real confidence in agentic commerce.
Once the network goes up and with the adjoining frameworks, Singularity will enable a new generation of sovereign agents.
