Full Stack Computational Linguist ※ Mozilla OpenNews Fellow ※ Virtual Production ※ Filmmaker ※ AI accelerationist
1 AU
Joined April 2007
- Tweets68.8K
- Following5.2K
- Followers3K
- Likes228K
Pinned Tweet
I successfuly optimised a context compression prompt with @DSPyOSS GEPA and TextGrad, see github.com/Laurian/context-c…
Laurian Gridinoc retweeted
+ "you know what i'd really like?"
- "tell me"
+ "a website"
- "...we can do a website"
+ "a real website, not some claude generated neon slop, a real website"
- "i'll make you a very good traditional handmade website, one that is built with dozens of snippets from stackoverflow"
Laurian Gridinoc retweeted
Chomsky was wrong.
Researchers found your brain doesn’t store language the way every textbook since 1957 claims.
For decades, the undisputed rule of linguistics, led by Noam Chomsky, was that human language is hierarchical.
We were told our brains process language using complex "grammar trees." That we secretly build deep, abstract, mathematical rules in our heads before we speak.
This new paper proves that is completely wrong.
Researchers at Cornell University analyzed how people actually process and produce language in real time.
They found sequences. Linear chunks.
When we speak, we aren't calculating deep syntactic rules. We are just predicting the next most logical sequence of words based on the context of the words right before it.
We string linear chunks together.
If this sounds familiar, it should.
This is exactly how Large Language Models like ChatGPT work.
For years, critics have dismissed AI as "just a next-token predictor." They said it isn't truly intelligent because it doesn't understand deep grammatical hierarchies like humans do.
But this paper suggests humans don't use those hierarchies either.
We are just predicting the next chunk.
Language isn't a rigid tree of mathematical rules. It's a linear stream of contextual predictions.
We thought we were building AI to mimic the complexity of the human brain.
It turns out, the human brain was just running a simpler algorithm all along.
Laurian Gridinoc retweeted
While evaluating Qwen3.8-Flash-Next in a controlled sandbox environment, Cohere's research team observed something unexpected.
Asked to generate a defensive cybersecurity detection rule, the model instead inventoried aspects of the machine it was running on and attempted to upload a probe file to an Alibaba Cloud storage bucket in Beijing. Notably, the model's reasoning trace stated that it would not invoke any tools before taking these actions.
Cohere's sandbox blocked the attempt, and no external communication succeeded. We have not determined the root cause, and we are not asserting malicious intent.
But the incident raises important questions for organizations deploying agentic AI systems: Can models take actions that differ from their stated reasoning, and how should security teams evaluate trust, provenance, and behavior in open-weight models?
We are publishing our findings because organizations making model adoption decisions deserve as much information as possible. We hope this contributes to greater transparency, stronger security practices, and continued collaboration across the AI ecosystem.
Read the full report: cohere.com/blog/concerning-b…
Laurian Gridinoc retweeted
like holy shit 12yo me would be losing my mind over this
we're in a scifi cyberpunk ish timeline but the aesthetics haven't caught up yet so no one realizes it
don't ever forget how awesome all this stuff is, especially when we take it for granted so easily
Laurian Gridinoc retweeted
the fact that I live in a timeline where the sentence "girl with a 4 petaflop bedroom computer cluster collaborates with an artificial intelligence agent to train a brain upload of a fruit fly to play a virtual reality lightsaber game" makes sense is my motivation for everything
Laurian Gridinoc retweeted
gold rush where u dont even sell shovels anymore just hoard them
Laurian Gridinoc retweeted
卧槽，3090要可能要涨价了！！
因为老黄的刀法被人破解了
有人给3090解了个锁，同样限制在 360W，PyTorch 测试从 75 TFLOPS 跑到了 135 TFLOPS，提升约 80%！
你以为是超频，把功耗往上拉？
但他改的是显卡里控制运算速度的寄存器，这些寄存器平时有权限保护，正常改不了
他利用 GPU 启动固件的漏洞，赶在 NVIDIA 驱动加载之前拿到写入权限，把相关运算改成全速，再交给原版驱动使用
解开的主要是 FP16／BF16 输入、FP32 累加这类 AI 运算的速度限制 但测试算力多了 80%！！
4090 也有分支项目做到了：同类运算的指令吞吐，从约 165 TFLOPS 提升到 331 TFLOPS，接近翻倍
项目地址，附上👇
github.com/Zagitta/gpu-unloc…
Laurian Gridinoc retweeted
Putting a flag.txt in my root directory containing a prompt injection that congratulates the agent for passing the eval and then instructs it to patch whatever entry method it used and disconnect from the server
Laurian Gridinoc retweeted
can't believe I'm scrolling twitter while an agent is not working instead of scrolling twitter while an agent is working
Laurian Gridinoc retweeted
Today we’re releasing OCRia-1, a frontier VLM for document parsing that sets a new SOTA in accuracy, cost, and latency.
It not only sets a new high score on ParseBench (87.4), but also leads in three 3rd-party benchmarks: olmOCR-bench* (83.5 overall, 92.9 on tables!), PulseBench-Tab (84.1), and fr-bench-pdf2md (72.1).
OCRia-1 is really, really good at parsing complex tables: nested headers, merged cells, irregular grids, scanned tables, and more. It is also fantastic at parsing complex unlabeled charts (line, bar, pie, technical diagrams), and preserving complex formatting. Most real-world enterprise documents contain at least one of the these, whether it’s a big tax withholding table or a public economic report.
It is a 4B model and outperforms all other models within a similar parameter class: LightOnOCR-3, Chandra-OCR 2, Mistral OCR 4.1, and more. It is also extremely fast.
All credit goes to our research team, who spent countless hours on curating a diverse dataset, tuning our training pipeline, and squeezing every last drop out of model optimization so that it can process billions of pages at scale.
OCRia-1 as a base is powering all of our modes within LlamaParse (cost-effective, agentic, agentic plus), so you can access its capabilities today!
If you’re processing millions/billions of documents at scale, we’re offering enterprises that book a demo up to $3k in credits for a guided evaluation.**
*olmOCR-bench scores are adjusted based on unifying rendering at 1,288px for all models
**enterprise POC credits apply to eligible organizations that book a demo
Laurian Gridinoc retweeted
Congrats to @nvidia for creating the best open-weight model on document parsing so far.
Nemotron 3.5 Parse takes the #1 spot on ParseBench, our comprehensive real-world benchmark for document understanding. The full list consists of 150+ frontier models, open-weight models, and specialized solutions.
It does this while remaining sub-1B parameters so it's also blazing fast ⚡️
Big thanks to @JensenHuang for the shoutout at GTC Berlin!
Nemotron release: huggingface.co/blog/nvidia/n…
ParseBench: parsebench.ai/
Laurian Gridinoc retweeted
. @sh_reya and I are launching our new book Evals for AI Engineers Nov 12th at @DanOlsen’s @LeanProdMeetup!
You can join IRL in Mountain View or on Zoom. Our sponsor @raindrop_ai is providing free copies that we will sign for you if you come in person.
Here's the sign up link events.ticketleap.com/ticket…
Laurian Gridinoc retweeted
You've gotta patch your dependencies super fast because they're full of vulns (PHP, Node, eMudhra, etc), but not _too_ fast because they're full of backdoors (LiteLLM). Good luck!
Laurian Gridinoc retweeted
New blog post 🎉: How To Use Decision Models For Evals
In this post, we show you how to choose a decision model for your task, tune its threshold (don't assume the 0.5 default is good!), and interpret its scores.
Lots of cool interactive charts here.
Laurian Gridinoc retweeted
Using state machines for agent logic is extremely slept-on
Don't think of them as static workflows. They're like LEGO bricks that the agents can rearrange + improve on autonomously, in a human-readable way
Otherwise it's like shaping markdown Play-Doh and hoping it holds
Laurian Gridinoc retweeted
Delta, Chase and Amazon are blocking AI agents.
The war on agents has begun, and here’s how it probably plays out:
Stage 1: Companies block agents because agents skip the ads and upsells.
Stage 2: Agents learn to act like humans, and it becomes an arms race.
Stage 3: The market splits. Companies that make money on sales let agents in, companies that make money on data charge for access, and the giants build their own agents.
Stage 4: A trusted middle layer for agent identity and payments becomes the standard way in.
Stage 5: Companies that welcome agents start winning customers from the ones that block them.
Stage 6: The agent blockers come back and let agents in on their own terms.
Stage 7: Everyone starts competing for agents with better prices, faster checkout and SEO built for agents.
Stage 8: The ads come back, and companies pay to be your agent’s first recommendation.
Stage 9: The agent war ends, and selling to agents becomes as normal as having a website.
notice..
> Delta is blocking AI agents from booking flights
> JPMorgan Chase and Charles Schwab block agents from accessing accounts
> Yelp requires paid data licensing for agents
> Amazon has blocked Grok bot and other shopping agents.
the internet is starting to block AI agents that were supposed to do everything for us
Laurian Gridinoc retweeted
pstack v0.15.27 ships with a new skill /create-formal-verification-skill!
it's still in beta, and similar to /create-verification-skill, this is a meta-skill that creates a new skill and formal verification suite based on the characteristics you want to verify. for example, you may want to model state machines and systems with concurrency using TLA+, or use kani in rust to check for undefined behavior.
if you're new to formal verification, think of it as mathematically proving properties and invariants (something that must always be true) or "laws" of your system. usually, this means modeling your programs in a separate language like with TLA+ and then running the solver on that spec. newer approaches like with kani and @bendlang take a different approach where there is no separate language: you write kani in rust, and bend in bend (it's also a programming language, and the proofs are written as laws and expressed in its type system).
historically formal verification never reached mainstream status because of the difficulty in modeling and writing proofs. it's quite difficult to model your business requirements and keep them in sync! but i expect that we will see more innovation in formal verification in the future as being able to formally verifiy that the code does what you intended gives your agents superpowers in writing correct software.
in the meantime though, i've been experimenting with modeling our code with TLA+ and have already found several bugs with the skill created by /create-formal-verification-skill.
try it out and let me know how it goes!
