Ricker
@0xRicker • 11,310 subscribers
AI researcher • developer • engineer • DMs always open
Shorts
![Whale bot printed $50k/week using Bayesian Update formula Start with prior from Markov state history, update on micro-signals in real time → posterior becomes your edge probability Formula: P(H|E) = [P(E|H) × P(H)] / P(E) (H = hypothesis like "BTC up in next 5 min", E = new evidence: order flow spike + vol cluster) Check him -> - Target ultra-short BTC/ETH/SOL/XRP Up/Down windows (5–15 min) - Layer evidence: net buys >2σ, on-chain tx acceleration, cross-asset momentum delta - Only enter if posterior shifts >10–15% from market price → high-conviction micro-edge - 92,722 predictions = ~300 trades/day compounding at scale Small belief updates × 300 trades/day × geometric compounding = $50k/week Merlin just shipped Whale Autotrade It tracks every profitable whale and detects the entry the moment it executes, mirrors it to your account instantly](https://image.24vids.com/tw-2055218443108950333/amplify_video_thumb/2055218028304814080/img/hxfuErS5UuD743JM.jpg)
![The Quant Who Turned Shannon's 77-Year-Old Formula Into +$555K in 30 Days He's not betting on crypto. He's compressing its uncertainty - one bit at a time His strategy: Shannon → Kelly → Crypto Up/Down The Formula D_KL(P ∥ Q) = Σ p(xᵢ) · log₂ [ p(xᵢ) / q(xᵢ) ] P = his model. Q = the market price. The result = how many bits of information he has that the market doesn't. That number IS the edge KL > 0.10 bits → Pro zone. Trade KL > 0.30 bits → Insane edge or bad math Every position is a binary, ultra-short crypto market: BTC, ETH, SOL, XRP - Up or Down on 5-min and hourly windows The same playground Shannon's math was built for Fastest way to copy-trade him even with $10 using: Kelly Sizing Position size scales with edge in bits: - High conviction (BTC Down 58.9¢): 2,999 shares - Medium (ETH Down 63.9¢): 900 shares - Long-tail (XRP Up 17.1¢): 158 shares Same recipe Thorp used to run 20 seasons with zero losing years While retail argues vibes on 5-min candles, this wallet runs KL-divergence and Kelly - 33,795 times in a row](https://image.24vids.com/tw-2051349084955455642/amplify_video_thumb/2051348578048647168/img/WK0ebTmnvlt8-vk8.jpg)
Videos
this is where REA × Kimi K3 starts to get dangerous. reverse engineering usually forces one model to keep too much of the app in context at once. REA changes the shape of the problem first. so the workflow becomes less like “read this codebase” and more like distributed forensics: map the surface → assign narrow investigations → trace relationships → compare findings → reconstruct the architecture the important part is that no single agent needs to understand the whole app. the swarm builds that understanding collectively. that’s what makes REA × K3 interesting to me: reverse engineering stops being limited by how much code one model can hold in its head. full course in the article below ↓
Ricker48,451 görüntüleme • 4 gün önce
Jev Engineering is what turns an agent stack into an actual control system and moves the expensive model out of every decision loop. and up to 193x faster and 444x cheaper in tests. the model shouldn’t decide everything. in this setup: request → structured state → Jev router → cheapest capable model → worker → relevance / approval checks → execution gate → tool the important part is that the decision layers don’t generate prose. they route → score → block → approve. so expensive models only get called when the task actually needs them. that’s the point of Jev Engineering: separate reasoning from decision-making, then make the decision layer measurable, cheap and fast. full breakdown in the article below ↓
Ricker182,717 görüntüleme • 1 ay önce
300 agents can find 1,000 sources. that still doesn’t make the research good the interesting part starts when those sources are forced to check each other. in K3 graph-native setup: 300 agents → 140 linked sources → 100% traceable claims → 9 contradictions surfaced one source confirms a number. another challenges it. a third connects the same entity from a different angle. so instead of: source → summary you get: source → entity → overlap → contradiction → verification → graph every new source becomes a node. if 3–4 independent sources support the same claim, confidence goes up. if 2 sources disagree, the contradiction gets flagged. if a claim has only 1 supporting source, it stays weak. a normal research workflow could have quietly shipped those 9 contradictions as facts. that’s why the breakthrough isn’t just 300 agents running in parallel. full breakdown in the article below.
Ricker227,257 görüntüleme • 2 ay önce
Jev Engineering is the layer most agent stacks are still missing. state → decision → action → verification → next state up to 193x faster and 444x cheaper in our tests. everyone is optimizing the model. Jev Engineering optimizes what happens between model calls. every agent eventually hits the same fork: state → multiple possible actions → one route has to win instead of sending every decision back to an expensive LLM call, Jev turns that into a dedicated layer: so the loop becomes: LLM → reason Jev → decide tools / agents → execute state → update Jev → decide again once decisions become their own engineering layer, you can benchmark, batch and verify them separately. full blueprint in article ↓
Ricker116,701 görüntüleme • 1 ay önce
Andrej Karpathy just said what no one wants to admit: "Your agent loop is generating garbage at scale and you can't see it." 1 output looks fine. 1,000 outputs = dead entropy, dead diversity. 90% of AI companies are building demos, not products. In a 20-minute conversation, Karpathy reveals the full reasoning stack
Ricker314,765 görüntüleme • 3 ay önce
300 agents shouldn’t be running all day. they should just appear for 28 minutes, finish the job, and disappear until next task the bigger an agent swarm gets, the less the individual agent matters. what matters is the system connecting them. 100 agents can create up to 4,950 possible pairwise relationships. 300 = 44,850. when a real signal appears, it spins up the workforce: 1 trigger → 100–300 Kimi agents → 5 live data feeds → up to 4,000 steps → verified artifact and that’s before adding: sources → claims → memory → tool calls → contradictions → retries so the architecture has to continuously compress all that activity into one shared state. more agents gives you more compute. the graph is what stops that compute from turning into noise.
Ricker76,968 görüntüleme • 1 ay önce
Jev Engineering is what lets one decision layer control hundreds of agent paths without turning the system into chaos. and up to 193x faster and 444x cheaper in tests. it’s deciding: → which model gets called → which tool gets access → which result survives that’s what the video is showing. one state enters. Jev turns it into structured decisions. those decisions fan out across dozens of routes, agents and tools. then everything collapses back into one verified state. so instead of: LLM → agent → tool → another LLM → another guess you get: state → Jev decision layer → parallel routes → execution → verification → next state that’s the point of Jev Engineering: more parallelism without giving every branch permission to improvise. full breakdown in the article below ↓
Ricker57,274 görüntüleme • 1 ay önce
Andrej Karpathy just reveales how LLMs actually thinks: "GPT-4 knows it failed. It just won't tell you unless you ask." >80% of GPT-4 errors are recoverable - the model already knows it screwed up. It has 80 transformer layers and spends the SAME compute on every single token as your brain In a 20-minute speach at Microsoft Build, Karpathy reveals the full psychology of LLMs. Worth more than any $500 prompting course you've seen on your timeline.
Ricker163,114 görüntüleme • 3 ay önce
Andrej Karpathy in Stanford classroom said: "GPT is not a language model - It's a general-purpose computer" 90% of AI Twitter still thinks it's just autocomplete. It's not. >90% of the tools built on top of LLMs treat them like a smarter search engine. In this 40-minute lecture, Karpathy builds nanoGPT live 300 lines, reproduces GPT-2, explains every single decision. Worth more than any $500 deep learning bootcamp.
Ricker117,471 görüntüleme • 3 ay önce
Built a Self Executing Agent Loop that can run 300 agents through 4,000 steps without needing a human to restart the process. - 300 agents. - 4,000 steps per run. - 5 live data feeds. - 3 verification passes. The important part isn't the agent count. It's that the system can execute, verify its own output, update context, and keep running without waiting for the next prompt.
Ricker55,374 görüntüleme • 1 ay önce
Sam Altman (CEO of Open AI) just said what no one wants to admit:: "You no longer need to write prompts, if you use GPT-6 Astra” In under 1 hour, he shows how to use GPT-6 Astra at a level most people probably haven’t even considered. You will realize that you use maybe 15% of what this tool is actually capable of. Watch the video, then read the guide below on how to get the most out of it ↓
Ricker33,925 görüntüleme • 1 ay önce
Jev Engineering changes the unit of optimization from “agent” to “decision.” that sounds small, but it changes the architecture. and up to 193x faster and 444x cheaper in tests. normal multi-agent stack: agent → prompt → tool → output Jev-style stack: shared state → decision boundary → selected branch → execution → measurement → state update now you can optimize the actual control points: latency per decision cost per fork confidence threshold retry policy branch survival termination condition the agents underneath can change. the models can change. the tools can change. the decision layer stays measurable. that’s why Jev Engineering feels more like systems engineering than prompt engineering.
Ricker21,662 görüntüleme • 26 gün önce
Jev Engineering is what turns a messy agent graph into a controlled decision loop. and up to 193x faster and 444x cheaper in tests. the video looks complex, but the idea is simple: Jev Engineering makes that decision explicit. state enters → routes get scored → confidence updates → weak branches die → strong branches keep moving → execution unlocks so instead of every agent improvising independently, the system keeps narrowing the graph. 0.00 → 0.41 → 0.68 → 0.80 → 0.93 and that score can decide: which model runs → which tool gets called → which branch retries → which result gets rejected that’s the point of Jev Engineering: don’t just give agents more intelligence. engineer how they make decisions. full breakdown guide below
Ricker19,376 görüntüleme • 29 gün önce
300 agents just worked in parallel. the hard part starts when they’re done. The real unlock is the shared context graph. 100 entities already have 4,950 possible pairwise relationships. at 300, that jumps to 44,850. 300 agents → thousands of steps → shared entities → shared relationships → one connected memory layer Every run adds more structure instead of starting from zero. That means the next agent doesn’t just get more data. It gets a better map of how everything connects. That’s the part people are underestimating about multi-agent systems.
Ricker34,737 görüntüleme • 2 ay önce
300 agents without context engineering is just 300 ways to lose track of the answer. a serious agent system starts looking less like: 1 model → 1 prompt → 1 answer and more like: 1 planner → N parallel agents → verifier → merge → memory → human gate once you have 10, 50, or 300 agents, the number of possible relationships explodes. 100 entities = 4,950 possible pairwise relationships. 300 = 44,850. 1,000 = 499,500. that’s why “just give the model more context” stops working surprisingly fast. you need different agents seeing different slices of the graph. the architecture around the model is becoming the product. full article below ↓
Ricker32,937 görüntüleme • 2 ay önce
300 agents can still give you bad research. unless the sources can check each other. the interesting part is what happens when every source can see every other source. K3 swarm doesn't just dump research into 300 separate write-ups. • every source becomes a node. • shared entities become edges. • single-source claims stick out as weak. so instead of: `300 agents → 300 answers` you get: `300 agents → sources → links → one research graph` and that's where things start showing up that no individual agent was explicitly asked to find. the article's example ends with 140 linked sources, every claim traceable to its origin, and 9 contradictions surfaced instead of silently shipped as facts. esearch stops being a pile of tabs. it becomes a system where the sources check each other. Book this & read full breakdown below
Ricker32,618 görüntüleme • 2 ay önce
300 agents sounds powerful until you realize they can create 44,850 possible agent-to-agent relationships. that’s the real scaling problem. 1 agent searches 10 pages. 10 agents can search 100. 300 agents can search thousands in parallel. but more agents also means more: • duplicate findings • shared sources • hidden relationships and if every agent returns its own isolated report, you’re left with 300 piles to reconcile manually. that’s why the graph matters. instead of: 300 agents → 300 reports you get: 300 agents → shared entities → edges → clusters → one connected research map 100 nodes already create up to 4,950 pairwise relationships. more agents give you more information. the graph is what stops that information from becoming noise. full breakdown in the article below ↓
Ricker27,887 görüntüleme • 2 ay önce
Andrej Karpathy dropped a lecture that makes every AI influencer feel stupid He just exposed the dirty secret of LLMs "90% of AI hype collapses when you realize even the builders can't explain what's inside." A 70B model is literally 2 files: parameters + 500 lines of C code >80% of AI safety work is patching holes in a sinking boat - Most people pay $1000 this knowledge. You’re getting it for free
Ricker38,790 görüntüleme • 3 ay önce
Jev Engineering turns one agent chain into a decision graph that can reroute itself and moves the expensive model out of every decision loop. the important part in this setup isn’t the number of agents. it’s that execution doesn’t follow one fixed path. and up to 193x faster and 444x cheaper in tests. every result can change what happens next: state → Jev decision → branch → specialist agent → result → score → reroute and Jev Engineering sits above that graph deciding: which route stays alive → which specialist gets control → when two branches should merge → when a result needs another pass → when the goal is good enough to stop by the end of the run: 5,400 executions → 0.93 goal score → $0.020 decision cost that’s why Jev Engineering is more than model routing. it’s the control layer that keeps a changing agent graph pointed at one objective. full breakdown below ↓
Ricker13,896 görüntüleme • 28 gün önce
Found a setup that replaces a team of researchers with 300 AI agents and one shared graph. the interesting part is what happens after all 300 come back with different pieces of the answer. because now you don’t have 300 agents. you have: 300 outputs → hundreds of sources → repeated entities → overlapping claims → contradictions → thousands of possible relationships and all of that has to collapse into one structure. that’s what the context graph is doing. instead of: agent → report you get: agents → sources → entities → edges → contradictions → verification → one graph every source becomes a node. every shared entity creates a connection. 300 agents can create information. the graph is what turns that information into memory the next agent can actually use. that’s the anatomy behind the setup ↓
Ricker19,999 görüntüleme • 1 ay önce