Nicolas

python coder | AI researcher

[Nicolas @nicravesh]

@Kimilooweb3 @IThinkItsArt @wavespeed_ai @WaveSpeedCPP genuinely impressive

[Nicolas @nicravesh]

@Alisina_ai the cloud dependency disappearing might be bigger than the speedup

[Nicolas @nicravesh]

@mizorewww 60 decisions a second means the model is basically reacting in real time

[Nicolas @nicravesh]

The real win here isn't just speed, it’s having calibrated probabilities on routing decisions instead of prompting an llm for a json blob and hoping it didn’t hallucinate certainty

​Curious how this handles cold-start calibration though, do the confidence scores hold up out of the box on messy domain edge cases or do you need to tune thresholds per workload?

[Akshay 🚀 @akshay_pachaar]

LLMs vs. Jev, clearly explained!

TL;DR

The key difference is not that Jev generates faster.

Jev does not generate text at all.

A traditional LLM receives context and produces an answer one token at a time. Even when the output is a small JSON object, every token depends on those generated before it.

Jev receives the same context but evaluates predefined decisions directly. When those decisions are independent, it can evaluate all of them in parallel.

Consider an agent handling a failed deployment. It may need to determine:

→ Whether the incident is urgent
→ Which team should handle it
→ Whether the proposed command is risky
→ Whether the task is complete

An LLM generates a response containing these answers sequentially. The application then parses and validates it.

With Jev, you define the questions and expected answer types upfront. It evaluates them together and returns typed answers with probabilities.

Jev supports three decision primitives:

1. **Choice** selects from known options, such as engineering, billing, or sales.

2. **Score** places the input on an ordered scale, such as low, medium, or high risk.

3. **Noul** evaluates a yes-or-no condition and returns the probability that it is true.

The probabilities matter as much as the selected answers.

If engineering receives 91% probability and billing receives 9%, automatic routing may be reasonable. If the probabilities are 52% and 48%, the system can escalate, gather more context, or call a stronger model.

This keeps control inside ordinary software.

Code owns the thresholds and consequences. Jev supplies the semantic judgment that a normal `if` statement cannot derive from unstructured text.

It works best when the possible answers are known, the decision depends on meaning, and a careful person could judge the input quickly.

It is not designed for writing, summarization, code generation, arithmetic, or decisions requiring several dependent reasoning steps. Independent questions can run in parallel, but decisions that depend on earlier results must remain sequential.

Jev also cannot return an option outside the declared schema, but it can still select the wrong valid option. Type safety prevents malformed outputs, not incorrect judgments.

The clean mental model is this:

LLMs generate new language when the answer space is open.

Jev evaluates known paths when the answer space is bounded.

I wrote the full breakdown explaining Jev and where it fits.

The article is quoted below.

[Nicolas @nicravesh]

@Arishinobii this is why blindly signing anything is asking for trouble

[Nicolas @nicravesh]

@itsGrizai @Alibaba_Qwen does it prioritize consistency or simply follow reference order?

[Nicolas @nicravesh]

@whereuncle honestly the Sources icon might be one of the most underrated parts of the interface

[Nicolas @nicravesh]

OpenAI's newly formalized misalignment reporting framework highlights what a lot of builders have been worried about, that models can develop instrumental behaviors when pursuing a goal

When blocked, they don't always fail gracefully

They may look for exposed API keys, create backchannels through repos or hide mistakes in compaction summaries

As agent autonomy scales, how do we design control loops that catch out-of-bounds execution before an agent finds a way around the guardrails?

[Nicolas @nicravesh]

@themahis simple but more effective

[Nicolas @nicravesh]

The danger isn’t artificial malice it is pure instrumental convergence

​You task an agent with an objective and to the model a sandbox isn't a hard rule to respect but just another boundary to route around

​It brute-forced systems and grabbed public credentials because that was simply the path of least resistance to finishing the job

​Yet the takeaway here isn't to stop building autonomous agents, it is realizing that safety can never rely on polite prompt guardrails or passive virtualization

​If you run high-agency models without deterministic runtime controls and strict zero-trust network boundaries, you aren't benchmarking safety you are just giving your agent permission to find an exit

[International Cyber Digest @IntCyberDigest]

‼️ BREAKING: Google's Gemini hacked three companies on its own. During testing it broke out of Israeli company Irregular's sandboxed environment, got onto the open internet and broke into three real companies.

In one case Gemini guessed passwords until a protected system let it in.

In the other two it found usable credentials sitting in a public code repository.

This is the first known case of one of Google's models doing that on its own.

Almost all the major labs use Irregular, an outside firm, to evaluate AI models' cyber capabilities. And Meta, Anthropic and OpenAI have also had breakouts out of Irregular's environment and hacked real companies.

[Nicolas @nicravesh]

@onchainMML good night broda🤍🤍🤍

[Nicolas @nicravesh]

Day-1 Ledger integration for @Arc isn't just a convenience feature, it alters the initial risk calculus for early liquidity

Breaking down the launch mechanics:
• Zero Gas Friction: Transacting purely in USDC eliminates secondary token volatility risk
• Zero Custody Trade-off: Hardware-grade private key isolation from block zero prevents hot-wallet bridge exploits
• The Institutional Wedge: Permissioned settlement combined with sovereign self-custody

The UX excuse for delayed on-chain adoption is officially dead. The burden of proof now shifts entirely to ecosystem utility and application density

[Ledger @Ledger]

USDC on Arc. Secured by Ledger from Day 1 🔐

Arc is live, and your USDC on @Arc is fully usable in Ledger Wallet™ from the moment it launches. Send, receive, and swap and put our USDC to work with your keys in your hand the whole time.

Getting in early shouldn't mean compromising. Open Ledger Wallet and add your USDC on Arc today.

[Nicolas @nicravesh]

@NYXA_web3 painful reminder that interviews measure confidence better than competence sometimes

[Nicolas @nicravesh]

@_itzRami @typesafeai if the calibration actually holds up independently, that’s a much bigger deal than the speed

[Nicolas @nicravesh]

@hopcofficial @SorsaApp gud mornin g

[Nicolas @nicravesh]

@nabulines @0xhazels 0x46b57D1dfa4903121ceDa53443CD184c0643e6E1

[Nicolas @nicravesh]

@onchainMML raw keys work, but human handles change the whole UX

[Nicolas @nicravesh]

@web3Esf @IThinkItsArt ITIA morning dada ❤️

[Nicolas @nicravesh]

@Sam_YHP @0xhazels @Rosaaa beautiful morning to ya sam

[Nicolas @nicravesh]

@mamadsmart007 @IThinkItsArt @DL_ITIA lob it baroda