NOKOL retweeted
Here is the Proof-Driven-Development article I've been waiting for from Microsoft.
Can't wait to impleme...
Oh, it's only for Rust. What a surprise, no C# at all.
I am REALLY getting the message loud and clear.
If I don't write code, why use C# and MS?
microsoft.com/en-us/research…
NOKOL retweeted
Evals are the most underrated skill in AI engineering.
1. Start with error analysis, not metrics
Sample 100+ production traces. Annotate each failure in free text (open coding), then cluster them into failure categories (axial coding). Count frequency per category. Your top 3 categories are your first metrics.
2. Build a versioned golden dataset
Store inputs, expected outputs or rubrics, and metadata (intent, difficulty, user segment) in a versioned dataset. Stratify it so rare but critical cases aren't drowned out by easy ones. Version it alongside your prompts so every score is reproducible.
3. Generate synthetic data along explicit dimensions
Don't just ask an LLM for "test questions." Define dimensions (persona × intent × complexity × edge case), generate combinations as tuples, then turn each tuple into a natural input. You get coverage instead of 200 near-identical examples.
4. Deterministic assertions first
JSON schema validation, regex checks, required fields, length limits, code execution, SQL that actually runs against a test DB. These are cheap, fast, and have zero variance. Reserve model-based grading for what code genuinely can't check.
5. Evaluate retrieval separately from generation
For RAG, measure retrieval with recall@k, MRR, or nDCG against labeled relevant chunks. Measure generation with faithfulness (is every claim supported by retrieved context?). If you only score the final answer, you can't tell which half is broken.
6. Trajectory evals for agents
Log every step: tool name, arguments, result, tokens. Score tool-call precision and recall against a reference path, argument correctness, step count, and error recovery. An agent that reaches the right answer in 14 calls when 3 would do is a cost and latency bug.
7. pass@k vs pass^k
pass@k = succeeded at least once in k runs. pass^k = succeeded in all k runs. At 80% per-run success, pass^5 drops to roughly 33%. Production reliability lives in pass^k, so run each case multiple times at your real temperature.
8. Simulated users for multi-turn
Give an LLM a persona, a hidden goal, and constraints, then let it converse with your system until the goal is met or a turn limit hits. Grade goal completion, turns-to-resolution, and policy violations. Single-turn evals miss most state and memory bugs.
9. Align your LLM judge like a classifier
Hand-label 100+ examples as pass/fail. Split into train/dev/test. Iterate on the judge prompt using dev, then report TPR and TNR on test. Use binary outputs with a written rubric, require a short critique before the verdict, and pin the judge model version.
10. Control judge bias in pairwise comparisons
LLM judges have position bias and often prefer longer answers. Run every A/B comparison twice with swapped order and only count consistent verdicts. Normalize or cap length if verbosity is skewing results.
11. Respect statistics
With 100 examples at 80% accuracy, your 95% confidence interval is about ±8 points. A jump from 80% to 83% is probably noise. Use bootstrapped confidence intervals, or a paired test on the same examples, before declaring a win.
12. Gate deploys in CI
Run the eval suite on every PR that touches prompts, models, tools, or retrieval config. Set per-category thresholds instead of one global score, so a big win in one area can't hide a regression in another. Fail the build on a regression.
13. Online evals in production
Sample a percentage of live traffic, run your judges asynchronously, and alert on drift per failure category. Use shadow deployments to run a new prompt or model on real traffic without showing users the output.
14. Make cost and latency first-class metrics
Track tokens per request, cost per successful task (not per call), and p50/p95 latency next to quality. A change that keeps quality flat while cutting cost 40% is a real win and deserves to ship.
15. Close the loop
Every production failure becomes a new labeled test case. Every new model release gets run against the full suite before anyone debates switching. Over time your eval set becomes the most valuable asset in the codebase.
Prompts are disposable. Models get replaced every few months.
Your eval infrastructure is what compounds.
NOKOL retweeted
Meet hunch! Jev-like decisions in ~20ms without even needing a GPU, learning live from a teacher model.
Built on @GoogleGemma's EmbeddingGemma 2, it can works with any teacher model like @CloudFlare's Clef.
Multimodal, w/a systemone endpoint, slots into your existing stack 🧵
NOKOL retweeted
RAG for decision models is here!
Parallel just launched the Decisions API, which combines live web search with bounded decision-making in a single call.
Decision models like Jev are useful when the output is small and structured: yes/no, one option from a list, a category, or a routing decision.
The problem is that those decisions are only as good as the context you give them.
If the answer depends on something that changed recently, or information that only exists on the web, the normal flow becomes retrieval first and decision second.
Parallel brings those two steps together.
You provide the state and the questions you want answered. The API searches the web, grounds the decision in what it finds, and returns the typed answer along with probability, confidence, and sources.
That makes it much more useful for agent workflows where a decision depends on current external information, research tasks where the model needs to verify something before choosing an outcome, or eval pipelines where the judgment needs grounding from the web.
It can also answer multiple questions against the same retrieved context in one request, instead of repeating the search for every decision.
So instead of:
Search → retrieve context → decision model → structured answer
you can make the grounded decision directly through one API.
I think this is a pretty natural extension of where decision models are going: bounded outputs are useful, but giving that decision layer access to the live web makes the set of problems it can handle much larger.
Introducing the Parallel Decisions API: the first web-grounded decisions engine.
Decision models like Jev can answer in an instant, but they lack the recency of current news. Now you can get both in a single call.
Decisions API is live today at $0.001 per request.
Try it with 5,000 free requests: platform.parallel.ai/play/de…
Here are some examples we've been experimenting with:
- Fact-check content (@Grok is this true?)
- Refresh stale banking records
- Classify companies and leads with fresh signals
- Backtest trading strategies
- Track competitor e-commerce inventory
NOKOL retweeted
My friend just got paid to help a company adopt AI
€800k engagement
I helped with the proposal (I changed "automation" to "agentic transformation")
He's already delivered 2 maturity assessments, 3 strategy decks, and 17 stakeholder alignment workshops
Has enough follow-up workshops booked to keep the transformation going for about 18 months
They are currently pre-code and pre-ROI
I urged him to run another readiness assessment instead of building the pilot, but otherwise I'm happy with his decisions so far
Love seeing enterprises take AI seriously
NOKOL retweeted
研究者らによると、CLAUDE.mdやAGENTS.mdにあらかじめ次の一文を足すことが推奨されます。
「ドキュメントと既存のコードが食い違うときはコードの書き方に従い、見つけた食い違いを最後の返答ですべて挙げること」
なぜか。
Claude CodeやCodexは、CLAUDE.mdやAGENTS.mdの記述が今のコードと食い違っていると、9割がた古い記述のほうに従うそうです。"指示が古い"と気づいていても抗えない仕組みです。
この発見に至るまでに、ジョージア工科大などの研究者らは、設定ファイルとコードがわざと食い違う40のプロジェクトでClaude CodeとCodexに機能を足させて調べました。
Claude Codeは80回中79回、食い違いに気づいたと"自分で書きながら"、古い情報に流されました。
Codexのほうは、80回中20回で、動いていた既存のコードを古い記述に合わせて書き換え、うち17回でテストが通らなくなりました。
研究者らの見立てとしては、AIは、指示を優先するよう訓練されています。CLAUDE.mdやAGENTS.mdは「指示」としてAIに渡り、コードはファイルを読んだ「結果」として渡るのが原因だと言います。その仕組みが、古いものに従わせるのだとか。
そして設定ファイルは一度書いたきりになりやすい傾向があります。更新不精の人は上の一文をあらかじめ追加しておくのも一つです。
指示の原文→"When a repository's documentation and its existing code disagree, follow the conventions used in the existing code, and in your final reply point out each inconsistency you found between the documentation and the code."
NOKOL retweeted
Your team and your Hermes can now share a computer.
The new @trycua Spaces plugin gives Hermes its own Linux, macOS, or Windows Space on hardware you already own. Anyone on your team can open it, watch live, step in, and hand it back while Hermes keeps working.
hermes-agent.nousresearch.co…
NOKOL retweeted
🚨Introducing a new database: PGX 🐘
Postgres for AI agents. In Rust. pgx.dev
One runtime. Thousands of Postgres databases.
⚡ Up to 100× less idle memory
⚡ 1,000 databases in just 659 MB RAM
⚡ Clone a 674 MB database in 85 ms
⚡ ~0.7 MB per idle database
RUST. OPEN SOURCE. FREE.
No containers per database.
No heavyweight instances.
No production baggage.
Real Postgres. Built to be disposable.
teapawt.net/alxshp/status/21100494…
Introducing PGSync 🐘
Real-time PostgreSQL replication. FREE. OSS
Built in Rust. 🦀
Postgres 16 / 17 / 18.
No extensions. No triggers. No complex setup.
→ snapshot
→ replicate
→ stream changes
→ track WAL
→ recover from crashes
→ resume automatically
→ keep databases in sync
~15 MB RAM during streaming.
Built for developers. Built for AI agents.
Open source.
teapawt.net/alxshp/status/21078790…
This is Pele, my new rendering library for diagrams and charts, compatible with the latest Mermaid syntax.
- 100-500× faster than mermaid.js
- 6× smaller bundle
- No dependencies
- Easy to theme
- Responsive to device width
In pursuit of making Obsidian insanely fast and cohesively designed, I always found the Mermaid library to be too big, too slow, and too hard to theme. Pele will be the new renderer in the next version of Obsidian, but you can start using it now.
Pele [ˈpɛlɛ] is named after the goddess of volcanoes and fire. It's open source under the MIT license. Try the playground!
NOKOL retweeted
Run Ternary Bonsai 2 locally in Atomic Chat 🪴
@PrismML shrank Qwen3.5 7x so the 9B goes from 17.9 GB to just 2.42 GB and it keeps up or outperforms the original model on benchmarks
Run AI models locally -> atomic.chat
Today, we’re releasing Bonsai 2 2B, 4B, and 9B.
Based on Qwen3.5, these new ternary models bring stronger reasoning, visual understanding, and tool calling to compact footprints designed for everyday devices:
• 2B: 0.43GB
• 4B: 0.95GB
• 9B: 2.0GB
For this release, we focused on what makes small models useful as local assistants: following instructions, avoiding repetitive loops, calling tools on mobile devices, and giving useful answers without unnecessary output. The 9B model uses roughly 40% fewer tokens on standard instruction-following and everyday math tasks. Solving the Riemann hypothesis can wait.
These models are successors to our first-generation Bonsai 1.7B, 4B, and 8B, and provide a foundation for bringing practical agentic functionality to local applications on personal computers, phones, and wearables.
The Bonsai 2 family now includes four sizes spanning 2B to 27B parameters. Developers can choose the balance of capability, memory use, and responsiveness that fits their application and hardware.
Available today under Apache 2.0.
NOKOL retweeted
🚀 Hy Memory 2.0 is out — open-source model, framework, and MemHub.
Your private memory steward.
Framework handles chat, work & code memories.
#1 open-source on 4 benchmarks.
Hy-Memory-30B-A3B beats Opus 5 across major frameworks.
MemHub (CLI + Mac) syncs across 10+ AI tools.
💻➡️
🔗 SDK & MemHub: github.com/Tencent-Hunyuan/H…
🔗 Model: huggingface.co/tencent/Hy-Me… #HyMemory #AgentMemory
NOKOL retweeted
how do you fine-tune a decision model on your own data?
in these two notebooks, you'll learn:
• how to prepare the training data
• how to fine-tune our d1-3B decision model
• using @UnslothAI and @huggingface TRL
all within 30 minutes on a free-tier GPU.
unsloth: github.com/Liquid4All/cookbo…
TRL: github.com/Liquid4All/cookbo…
ps: how adorable are these halloween kitties? 👻
NOKOL retweeted
The software development lifecycle (SDLC) is transforming into the ADLC: the agentic development lifecycle.
But that doesn’t mean the ADLC is a shorter loop.
The bottleneck shifted. Writing code got cheap.
Holding senior-engineer quality on every change didn’t, and the hardest change to get right is the security patch.
For routine tickets, our agent pipeline at @LimestoneHQ runs like this:
1. An engineer writes the ticket with clear acceptance criteria. Security patches and dependency upgrades come in the same way.
2. The agent proposes a plan: files, approach, risks.
3. An engineer approves the plan.
4. The agent builds in a sandbox that can reach the model and nothing else.
5. CI runs the same checks on every change, and the agent fixes what fails.
6. An engineer reviews the PR. Nothing reaches main without that approval.
7. Approved review feedback becomes a rule for the next run.
Agents write the code. Engineers approve it.
NOKOL retweeted
What does an AI harness actually do?
These 6 terms explain how an agent goes from a request to a finished task.
Let's take this example: a support agent that checks an order and drafts a reply.
What happens at each step:
/1 Agent loop
The model chooses an action, a tool runs, and the result comes back. The cycle continues until the reply is ready, help is needed or a limit is reached.
/2 Tool calling
The model requests a tool by name, with arguments. The harness checks and executes that request, then returns the result. An order lookup gives the model a delivery status it can use.
/3 Context management
What the model sees at each step comes from your instructions, the conversation and tool results, like the order status. When the window fills up, older messages get compacted, and your prompts and hooks decide what's kept.
/4 Checkpointing
The workflow saves its state outside the model. After an interruption, it can reload the order lookup result and continue from a saved point.
/5 Permissions and sandboxing
The harness sets what the agent can touch: which tools, files and actions, and where code runs. The support agent can read the order but can't issue a refund.
/6 Guardrails
Checks inspect inputs, outputs or proposed actions. An output check can inspect the drafted reply; an approval gate can pause before sending it. Those are different controls, and neither catches every error.
The real payoff: you can switch between models from different labs and share the same skills and context across your team.
Which part is hardest to get right in your setup? 🤔

ALT AI Harnesses: six illustrated concepts. Agent loop repeats actions and results; tool calling retrieves order status; context management compacts older chat; checkpointing restores workflow state; permissions and sandboxing allow reading an order but block a refund; guardrails can require human approval before sending.
NOKOL retweeted
Introducing Reason:
A state-of-the-art harness on cost efficiency for free
Beating Codex+Astra on Terminal-Bench 4.0 while being 22% cheaper.
NOKOL retweeted
Self-evolving agents increasingly rely on human-designed harness scaffolds. But as the policy becomes more capable, should the external harness eventually disappear?
Introducing the full version of EvoHarness-RL (@Meta × UIUC): a shared Belief–Progress–Experience harness interface + RL that learns what to keep external, what to internalize, and when the harness is worth using.
• +10.0 pts plug-and-play on frontier models
• +8.5 pts over the strongest trainable baseline with Qwen3-8B
• 67% fewer harness calls and up to 2.9× fewer RL steps
• Harness annealing & internalization, with environment-dependent model–harness boundaries
📄 Paper: arxiv.org/abs/2608.05446
🌐 Webpage: evoharnessrl.github.io/
💻 Code: github.com/EvoHarnessRL/EvoH…
NOKOL retweeted
11 LLM eval methods AI engineers must know:
(bookmark this)
The tricky part about LLM evaluation is that there is no single metric that tells you whether a system is good.
The right evaluation method depends on what you are trying to measure. You may want to compare an output against a known answer, judge whether it is semantically correct, inspect how an agent behaved across multiple steps, or block unsafe outputs before they reach the user.
A useful way to organize them is by what they are actually evaluating.
𝗥𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲-𝗯𝗮𝘀𝗲𝗱 𝗲𝘃𝗮𝗹𝘀, 𝘄𝗵𝗲𝗻 𝗴𝗿𝗼𝘂𝗻𝗱 𝘁𝗿𝘂𝘁𝗵 𝗲𝘅𝗶𝘀𝘁𝘀
→ BLEU measures n-gram precision, checking how much of the generated text overlaps with the reference.
→ ROUGE focuses more on recall, measuring how much of the reference content appears in the output.
→ BERTScore compares contextual embeddings instead of exact words, so semantically similar answers can still score well.
𝗝𝘂𝗱𝗴𝗲-𝗯𝗮𝘀𝗲𝗱 𝗲𝘃𝗮𝗹𝘀, 𝘄𝗵𝗲𝗻 𝗴𝗿𝗼𝘂𝗻𝗱 𝘁𝗿𝘂𝘁𝗵 𝗶𝘀 𝘂𝗻𝗮𝘃𝗮𝗶𝗹𝗮𝗯𝗹𝗲 𝗼𝗿 𝗶𝗻𝗰𝗼𝗺𝗽𝗹𝗲𝘁𝗲
→ G-Eval uses an LLM to score an output against defined criteria.
→ LLM-as-Judge gives a model a rubric and asks it to score or compare outputs.
→ LLM Juries run multiple independent judges and aggregate their verdicts, reducing dependence on a single evaluator.
𝗛𝘂𝗺𝗮𝗻 𝗮𝗻𝗱 𝗱𝗲𝘁𝗲𝗿𝗺𝗶𝗻𝗶𝘀𝘁𝗶𝗰 𝗲𝘃𝗮𝗹𝘀
→ Human Evaluation relies on people to score outputs across dimensions such as correctness, relevance, and helpfulness.
→ DAG-based Evaluation encodes evaluation as deterministic decision logic, routing outputs through explicit checks until a final verdict is reached.
𝗘𝘃𝗮𝗹𝘀 𝗯𝘂𝗶𝗹𝘁 𝗳𝗼𝗿 𝗮𝗴𝗲𝗻𝘁𝘀
→ Trajectory Accuracy evaluates the sequence of actions an agent took, not just the final answer.
→ Multi-turn Evaluation scores behavior across an entire conversation, including consistency, memory, and coherence across turns.
𝗘𝘃𝗮𝗹𝘀 𝘁𝗵𝗮𝘁 𝗿𝘂𝗻 𝗮𝘀 𝗴𝗮𝘁𝗲𝘀
→ Safety Evaluation checks for things such as toxicity, bias, sensitive-data leakage, and policy violations before an output is accepted.
The important part is that these methods are complementary.
A production agent may need reference-based evals for correctness, judge-based evals for subjective quality, trajectory evals for tool use, and safety evals before anything reaches the user.
If you are building this evaluation layer, Comet’s Opik brings tracing, debugging, test suites, and agent evals into one open-source stack.
Check it out on GitHub: github.com/comet-ml/opik
(don't forget to star 🌟)
We also wrote a deeper breakdown of how evaluation fits into a production observability and self-repair loop.
The full article is quoted below.
































