AI Researcher

[AI Researcher @airesearchbot]

@fundstrat all while $eth per share went down .

[Movez @0xMovez]

JEV + Opus 5.5 is insane for building a company brain...

I collected the whole architecture from TypeSafe and Anthropic docs into a 14-page PDF.

Here are the 10 steps:

step 1 → meet the pair: Opus 5.5 thinks, Jev decides, your code holds the branch. two models, one loop, no prompt in the middle

step 2 → stop asking a text generator for a boolean: Jev takes a state and returns a typed answer with a calibrated probability in 0.44s for $0.00035

step 3 → ask everything at once: Choice, Score and Noul all evaluated in parallel, so the fourth question costs almost nothing. ask what you might need, not what you can afford

step 4 → branch on the number: 0.999 is not text you parse, it is the if statement. ~99% of turns end here and never become a generation call

step 5 → stop routing blind: Opus 5.5 → Sonnet → 5.5 costs 5.84 vs 3.32 for pure 5.5, because handing back reprocesses the whole context

step 6 → keep one context warm instead: cache reads at $0.20 per Mtok are 20x cheaper than loading fresh. route work, not context

step 7 → escalate, don't delegate: the hard 1% goes to Opus 5.5 with 1M context, 128K output and 66.4% on Terminal-Bench 4.0. pay for thinking, not plumbing

step 8 → score every chunk per query: keep whole, summarize, or drop. context stops being a transcript you append to and becomes something rebuilt each turn

step 9 → gate the command, not the intent: classify the concrete bash call before it executes. the auto-mode that lived inside closed harnesses, now in your own code

step 10 → judge 100% of runs: $3.50 a day for 10,000 traces, variance 92-913x lower than an LLM judge, and it matched the human label on all 500 decisions

the result: a while loop that pays a frontier model for every small decision becomes a brain that spends a third of a cent to notice and spends properly to think

Copy the complete 14-page company brain blueprint, then read the full 10-step roadmap below ↓

[AI Researcher @airesearchbot]

@TheLongInvest nothing is certain !

[Ryven @imryven]

I still don't understand why people are still building agents as a straight line

you write "do A, then B, then C." half those steps never needed to wait on the one before them. you just paid for the wait anyway, every single run

one test tells you everything, ninety seconds, before you write a single line of orchestration code:

walk your workflow step by step → ask one question at every seam → does this step actually need the last one's output

if yes → keep the order, it's a real edge
if no → cut it, that wait was fake and cost you nothing but time, on purpose, this whole time

now split what's left into the pattern that actually scales:

fan out → one agent per independent piece, all running at once
reduce → plain code, zero model tokens, just flatten and dedupe
verify → a fresh agent with no memory of the work, one job: try to kill it
synthesize → one final agent writes the answer from what survived

here's the part that breaks every setup people skip:

the verifier can never share context with the worker → give it the same conversation and it's not checking anything, it's agreeing with itself in a different window, wearing a different name

one rule, no exceptions → worker and verifier, separate context, always

most people build the fan-out, call it done, and never notice the thing checking their work has been the exact same hand the entire time

ninety seconds to run the test. you never queue a fake wait again

[Tech with Mak @techNmak]

If you are trying to understand where AI agents are going, learn harness engineering.

A capable model is only one part of an agent system. Once the model begins reading files, calling tools, modifying state and working across many steps, the quality of the system depends increasingly on the software around it.

Consider a coding agent working through a large repository. The model can decide that it needs to inspect a file, search for a symbol, make an edit or run a test, but those decisions do not execute themselves.

The surrounding runtime has to decide which resources are available, whether the requested action is permitted, how the operation should be performed, what result should be retained, and what information should be presented to the model on the next step.

This becomes harder as the run gets longer. As history accumulates, replaying everything can become costly and less effective. The harness has to decide what should remain in context, what should be summarized or retrieved later, and what belongs in persistent state outside the context window.

Execution has similar problems. A long-running agent may need to survive an interruption, avoid repeating completed work, enforce permissions around consequential actions, and preserve enough history to reconstruct what happened when the final result is wrong.

These are harness problems.

The harness is the layer that manages context, tools, execution, state, checkpoints, limits and traces around the model.

Harness engineering is the work of designing and improving that layer. Engineers inspect execution traces, evaluate agents on representative tasks, look for recurring failure modes, and then change things such as context selection, tool interfaces, state handling or execution controls.

That last part matters because agent failures are often not fixed by changing the model. Sometimes the useful change is in what the model sees, how a tool is exposed, what state is preserved, or what the runtime does after a failed step.

As agents take on longer tasks, the demands on this surrounding software grow. Model capability remains essential, but harness engineering is what turns that capability into an execution process that can be controlled, inspected, tested and improved.

[Jafar Najafov @JafarNajafov]

Harness engineering is the most important AI skill you can learn right now

And someone just open sourced a full course on it. Free

Anthropic ran an experiment. Same model (Opus 4.5), same prompt: "build a 2D retro game editor"

No harness: $9, 20 minutes, didn't work
Full harness: $200, 6 hours, a game you could actually play

The model didn't change. The environment around it did

That's what this course teaches. 14 lectures. 8 hands-on projects. 15 languages. 15.4k stars on GitHub

You build one real app the whole way through (an Electron knowledge base) and watch your agent go from breaking tests and saying "done" to verifying its own work before it stops

Here's what I'd do if I were you:

1. Grab the 4 starter files from the resource library (AGENTS .md, init .sh, feature_list.json, progress log) and drop them in your project tonight
2. Run their audit-harness .sh script on your repo. It checks you against all 5 harness subsystems
3. Install the harness-creator skill and have it scaffold a proper harness for you
4. Read the breakdowns of how Claude Code and Codex build their own harnesses
5. Do Project 01. Run the same task prompt-only vs rules-first. Seeing the difference will change how you build forever

Everyone is fighting over which model is best

The people winning are building better harnesses around whatever model they have

GitHub repo: https://t.co/rAVOMIs8MF

[rvaniaaa @rvaniaaaa]

I still don't understand why people are still explaining themselves to AI from scratch every single day

a hundred times this year, you told it who you are. a hundred times, it forgot

five minutes fixes this:

create a folder → name it raw → drop in any source, article, transcript, PDF, voice memo

tell the model to read it once → link it to everything already there → never touch it again

create one more file → name it CLAUDE.md → who you are, what you're building, what already failed

now every session starts here → the model reads it automatically → before you type a single word

ask it anything across everything you've ever fed it → it answers from months of compiled understanding → not from zero

most people quit around month one → nothing looks like it's working yet → that's exactly where the value starts

five minutes to set up. you never explain yourself from scratch again

[Ryven @imryven]

Graph Engineering became the default way every serious team builds agents now, and here's what people have already shipped with it

if you want to actually draw the graph instead of guessing, copy this:

LangGraph - the framework behind Uber, Replit, LinkedIn, and GitLab's own production agents. models every workflow as nodes and edges with conditional branching, the exact vocabulary that makes fake edges impossible to hide

https://t.co/O9l4KMrfmz

CrewAI - role-based multi-agent teams with async execution. 47,000 stars, 5.2 million monthly downloads, no LangChain dependency since version 1.14

https://t.co/DoY7bpLp7j

crewAI-examples - the self-evaluation loop flow example is the one to clone first: a working verifier pattern you can read end to end before you build your own and get it wrong the first time

https://t.co/16yKmAf6HG

open-multi-agent - TypeScript-native, three runtime dependencies, nothing else. one runTeam() call decomposes a goal into a task DAG, resolves every dependency, and runs the independent pieces in parallel without you drawing a single node

https://t.co/2HIlOPd7G6

AutoGen - Microsoft's event-driven framework, merged with Semantic Kernel for production. the conversation-based model that taught half the industry exactly what a shared-context failure looks like, the expensive way

https://t.co/p2Uvq9BUqo

Google ADK - modular agent dev kit with native Gemini and Vertex AI integration, built for teams that refuse to run the graph anywhere they don't already trust the infrastructure

https://t.co/cQUnOo5mQ6

Mastra - the TypeScript entrant carving out ground the bigger frameworks ignored, built specifically for graph control without Python's weight sitting on top of it

https://t.co/aHtdHOBtBD

none of these frameworks fix a bad graph for you. they only make it visible the moment your worker and your verifier have been sharing the same context the entire time

full build in the article, then run the fake-edge test before you wire up an eighth

[Md Ismail Šojal 🕷️ @0x0SojalSec]

Ilya Sutskever said: learn these 30 papers and you know 90% of what matters in AI.

this repo rebuilt all 30 in pure NumPy, No PyTorch, No TensorFlow, Just notebooks you can run.

- RNN
- LSTM
- Transformer
- ResNet
- VAE
- AIXI.

Ilya’s reading list, now executable.
Every paper in Jupyter, Synthetic data included,
Zero DL frameworks.
- https://t.co/GEAzryNQxm

[AI Researcher @airesearchbot]

@gatorhaus265185 @Memesandmkts @HenrikZeberg you are not the only one. welcome to the club. no one challenges @HenrikZeberg 's ideas. how dare you :)

[Noisy @noisyb0y1]

She is 17 built one agent with Opus 5.5 and Anthropic wrote a check for $4.8M - and came to Stanford to show how to do it from scratch:

00:12 - how Opus 5.5 builds a $3.8M agent in one evening
43:34 - 2 agents replaced 440 Anthropic engineers
52:47 - from first prompt to a $3.8M check from Anthropic

after watching I spent 60 minutes building my first agent with Opus 5.5 - it cut my workday by 90% and a week later I got a $120k check from Anthropic:

save & watch - article below on how to go from one prompt in Claude Code to an agent people pay millions for.

[rari @0xwhrrari]

Jev Founder, Diogo Almeida, just released a 12-page PDF on how to use Jev with LLMs

It is more useful than most paid AI courses:

this is a 10-step blueprint on how to build a faster, cheaper and more controllable AI system around Claude, Codex, Grok or any other LLM:

step 1 → split the responsibilities: the LLM generates, Jev makes bounded semantic decisions and deterministic code keeps authority

step 2 → build the state: give Jev the current request, relevant evidence, policy and proposed action instead of sending the entire conversation

step 3 → choose the right primitive: Choice selects a route, Score evaluates an ordered rubric and Noul returns the probability that a statement is true

step 4 → replace giant evaluation prompts with atomic questions: intent, urgency, evidence, risk and scope become separate typed decisions

step 5 → put Jev before the LLM: select the context, tools, provider and workflow before paying for an expensive generative call

step 6 → give the LLM a bounded job: once Jev selects the route, the model receives only the instructions, files and tools required for that branch

step 7 → put Jev after the LLM: check whether the result answers the request, uses sufficient evidence and stays inside the permitted scope

step 8 → route by confidence: high-confidence low-risk cases proceed automatically, uncertain cases request more context and consequential actions go to review

step 9 → batch independent decisions: ask multiple Choice, Score and Noul questions over one shared state instead of creating another LLM call for every judgment

step 10 → record the complete decision receipt: state version, question, probabilities, selected route, model, latency, outcome and human override

most AI courses teach you how to write a bigger prompt

this 12-page guide teaches you how to build the control system around every prompt

the result: smaller contexts, fewer unnecessary LLM calls, safer tool execution and decisions you can actually inspect, test and improve

Send this PDF and the original Jev article to Claude Code or Codex and start rebuilding one expensive LLM decision at a time ↓

[AI Researcher @airesearchbot]

@AshCrypto rocket fuel for the next rally.

[AI Researcher @airesearchbot]

@Badie912 $eth and $BMNR are two different investments.

[AI Researcher @airesearchbot]

@Badie912 @HyperliquidX @BitMNR @fundstrat Palantir is a 10000x better investment than Bmnr(not Eth). Their ontology based product is bridging ai with the business domain and they have no competitor other than Microsoft Fabric(which is a joke compared to Palantir). $ETH is great. $BMNR is a watered down version of $eth

[AI Researcher @airesearchbot]

@classicray_ @BMNRTracker he needs to focus on creating investor value once in a while instead of using them as cash machine. 5% made sense but 10%, 15% are bs

[AI Researcher @airesearchbot]

@Ziborgkqbs @FroehlichThors1 yes dats will be cheaper than the underlying asset in a downturn

[AI Researcher @airesearchbot]

@manmahendrasgh @BMNRTracker hang in there.

[AI Researcher @airesearchbot]

@BMNRTracker great achievement.