Уже хорошо

[Percy Liang @percyliang]

🚢 Marin 535B-A23B started training this week! As usual, the whole process is open.
Voyage plan: pretraining (80%) + midtraining (20%) on 18.75T tokens on 11 x GB200 NVL72 for ~3 months (2.7e24 FLOPs). Post-training will follow.
Before kicking off the run, we trained a 4-rung scaling ladder from 1.6B-A61M (48B tokens) to 27.7B-A1.2B (926B tokens) to debug issues, and to make a forecast of our hero run. This is by far our biggest run, so definitely expecting the unexpected.

[AJ @ItsmeAjayKV]

Xiaomi just showed its AI Cube Prototype and this could become a serious GB10 competitor from China 👀

- 3 custom chips: Xring O3, O100, D100
- 200 TOPS NPU
- 1.22 TB/s AI memory bandwidth
- Up to 160GB unified memory
- 150W sustained power
- 120B models running locally

Xring O100: 1.22TB/s + 330 t/s on a 150w AI box is 🔥

Once it hit's the marked, going to sell like hot cakes.

[Cactus Compute @cactuscompute]

We release Needle 2: A 14MB agentic LLM for phones, wearables, smart home, robots and microcontroller. The whole model is a single 14MB binary that runs a full session in 28MB of RAM. It is built on our Simple Attention Network findings, compressed to CQ2-bit with Cactus Quants, and baked into its own engine.

Needle 2 has 45m parameters trained from the ground up on 140B tool call, device use structured generation tokens. On mobile device use benchmarks, Needle 2 trades wins with frontier small LLMs like LFM2.5 230M, Apple FM Gemma-270m, at 5× to 70× smaller, and 2 bits against their f16.

Needle hits 500 tokens/sec decode speed on a Raspberry Pi 5, between 400–1,500 tokens/sec on VR devices like Meta Quest 3S and Apple Vision Pro, and ranges 300–700 on sub-$200 phones such as the Samsung A-Series. Needle also runs on newer microcontrollers like ESP32.

A conventional transformer of Needle's width and depth spends 164 MFLOPs per token, and even one squeezed down to Needle's parameter count spends 87, Needle spends 70. Even on a high-end phone, an always-on assistant lives inside a power budget; every MFLOP is milliwatt-hours, and Needle spends 7x to 85x fewer of them per token than the smallest performant LLMs.

Read more: https://t.co/dLK2tIKXQu

[Dan Schwarz @dschwarz26]

AI forecasting is now approximately superhuman. Today, FutureSearch is exiting our public beta and launching to everyone.

FutureSearch is the original AI forecasting company, started in August 2023. We’re currently #1 of 194 in the most competitive AI forecasting tournament, and we score above the #3 and #2 human forecasters in the premier mixed human-bot tournaments. We’re beating the crowd on Kalshi with a pure forecasting strategy, all our forecasts and trades there are public.

Thousands of people used the beta and ran >10k high-effort forecasts. Ask it anything about the future! We now support decision forecasts too: “If I do X, will I achieve this outcome?”

This video shows the part we’re proudest of: world modeling. Forecasts draw on a persistent latent representation of the future, and we’ve shown it improves accuracy. The more your forecast on a domain you care about, the higher accuracy you should expect.

It’s free to try. https://t.co/e0JKSLzxVZ

[Rion Wu @rionaifantasy]

发明这个插件的国人真踏马牛逼。。。😤

一个插件，直接接入59个数据服务、1000多个接口：

无论是社交媒体平台（油管、X、Instagram、抖音、小红书、公众号、telegram、B站、领英…）
还是电商平台（淘宝、咸鱼、京东、亚马逊……），
甚至是搜索平台和加密货币平台，

都可以在任何主流agent中无脑调用（Codex、Claude Code、Hermes、Openclaw、workbuddy、kimi……）

[Suraj Sharma @suraj_sharma14]

If you can build these 12 Agentic AI projects.

You're hired.

Project 1: Structured Output Agent
Enforce Pydantic JSON schemas, validate tool responses, retry on parse errors, log validation failures.
→ Shows: You can make LLMs reliable not random

Project 2: RAG Agent with Citation Grounding
Retrieve context, generate answers with sources, flag low-confidence responses, fallback to search.
→ Shows: You can prevent hallucinations at scale

Project 3: ReAct Planning Agent
Observe → think → act → reflect loop, max iteration limits, self-critique, graceful degradation.
→ Shows: You can build agents that don't infinite loop

Project 4: Multi-Tool Orchestrator Agent
Dynamic tool registry, capability-based routing, permission scoping, parallel execution, conflict resolution.
→ Shows: You can coordinate complex workflows

Project 5: Memory-Enabled Conversational Agent
Short-term buffer + long-term vector recall, context compression, relevance scoring, cross-session sync.
→ Shows: You can build agents that remember users

Project 6: Human-in-the-Loop Approval Agent
Uncertainty detection → pause → request human input → resume with validated context, full audit trail.
→ Shows: You can build safe, compliant systems

Project 7: Cost-Aware Agent Router
Token budgeting per task, model routing by complexity/cost, early exit on confidence, cost-per-decision analytics.
→ Shows: You can reduce infra costs by 40-60%

Project 8: Event-Triggered Automation Agent
Listen to webhooks/queues, execute workflows on triggers, idempotent execution, dead-letter handling, retry logic.
→ Shows: You can build production automation not demos

Project 9: Multi-Agent Debate System
Multiple agents propose solutions, critic evaluates, voting/consensus logic, aggregator synthesizes with confidence.
→ Shows: You can orchestrate swarms not single agents

Project 10: Self-Reflective Agent with Auto-Eval
Execute → evaluate via LLM-as-judge → critique reasoning → regenerate with constraints, log improvement metrics.
→ Shows: You can build systems that improve over time

Project 11: Production Agent with Observability
Deploy with LangSmith/Arize tracing, latency/cost dashboards, alerting on loops/failures, canary testing, rollback.
→ Shows: You can ship to production not just localhost

Project 12: Open Source Agent Framework Contribution
Extend LangGraph/CrewAI/AutoGen with new pattern, write docs + demo, publish benchmarks, submit PR + tutorial.
→ Shows: You're a community builder not just a consumer

(Bookmark this)

happy building...

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

A 27B Uncensored model that built for specifically for offensive security tooling (need 12 GB)

- Fine-tuned on real bug bounty reports & CVEs
- Generates complete, ready-to-run Nuclei templates, Full CVE PoC script, Webshell upload bypass, and exploits, code reviews
- Zero refusals. Full artifacts every time.

trained with 2,541 of real bug bounty & offensive security reports.

Q6_K quant (21GB) for maximum quality on server-grade GPUs.

[Alex C. @alexcovo_eth]

Fugu + Hermes Agent = the ultimate combo right now

@SakanaAILabs Fugu (especially Ultra) is a genius multi-agent orchestrator — it dynamically routes, plans, and coordinates frontier models (GPT, Claude, Gemini etc.) behind one seamless API. Crushes complex coding, reasoning & multi-step workflows.

@NousResearch Hermes-Agent is the persistent brain: long-term memory, auto-builds skills from experience, runs 24/7, integrates with your tools/apps, and self-improves over time.

Together? Magic.

• Fugu handles the heavy, high-intelligence orchestration on tough tasks
• Hermes gives it context, persistence, reusable skills & real-world execution

Users already report big Improvements running Fugu Ultra inside Hermes. One call becomes a smart team that remembers you and levels up daily. (as per Grok)

I'm going to try it and see what's up.

[Tom Osman 🐦‍⬛ @tomosman]

This "loop" automation is nuts inside of Codex.

"/goal go over every single feature in this app create a user story with expected behaviour based on the code keep a single canonical spreadsheet tracking the features status
- when done switch loop to testing every user story and documenting all errors
- when done fix every logistical error or ux error
- test every user behaviour again post fix"

Shoutout to @MatthewBerman for the heads up.

Hundreds of user stories being worked through like it's nothing.

[管四 @guansi]

今天看到一种说法，说 Claude Fable 5 之所以这么强，并不完全是模型本身变聪明了，而是后台可能给每个用户偷偷配了一个 Claude Code。用户每提一个问题，后台先跑一遍 Agent、查资料、验证、推演，最后再把结果返回给你。

我第一反应是：卧槽，好像有点道理。第二反应是：那 Claude Fable 5 突然就没那么神秘了。

但仔细想想，这反而是个好消息。因为如果真是这样，那说明突破点未必是模型本身，而是模型、Agent、工具调用和长链路执行组合出来的系统能力。

模型能力不好追，工程能力反而更容易追。某种意义上，这甚至给国产模型指了一条路。

最可怕的从来不是别人比你聪明，最可怕的是别人找到了正确的系统架构。

[Gerard Sans | Axiom 🇬🇧 @gerardsans]

🚨 Claude Fable 5 is NOT a vanilla LLM but an agentic system dressed as a regular model.

A leaked system prompt (link in replies) confirms what many suspected:

• Full Linux sandbox with bash & file editing
• Persistent storage API + web/image search
• Safety classifiers that silently fall back to Opus 4.8 while you still pay Fable rates

Anthropic’s own docs say Fable 5 is built for “multi‑day autonomous sessions, delegating subagents, checking its own work”.But benchmarks compare it to raw models like GPT‑5.5.

That’s not a level playing field.
It’s comparing a model + agent harness to a bare LLM.

Full X thread with all findings including leaked prompt breakdown and invariant gaps coming later.

#Fable5 #NewCategory #AgenticAI

[Siqi Chen @blader]

fable is expensive

wrote a quick arbitrage skill for claude code to offload the hard things to fable and everything else to gpt 5.5 xhigh

it will try to be always on or you could say "implement with arbitrage"

https://t.co/y9FkI41I76

[Alex Finn @AlexFinn]

Loops are clearly the future of AI coding

The issue is, it’s being completely gate kept. And I think I know why

Over the last few days both OpenAI and Anthropic employees have been vague posting about loops. None have explained how they’re actually doing it

That’s because loops are the last moat

If everyone has the same level super intelligence, then using the AI no longer gives you an advantage

But if you come up with a system that allows your AI to work autonomously, giving 1000x leverage to each person in your org, then you have a legit moat again

If Anthropic shared their internal loop system with the world and stopped gatekeeping, their team would no longer have any advantage over any other lab

That’s why every frontier lab employee is gate keeping right now. That’s why everything on your timeline is a vague post. Loops are true technical IP.

This is why it’s so critical you start developing your own automated loops with your agents. Like literally right now.

Fable 5 leveled the playing field. Anyone can now build anything they want. Loops are what give you the high ground in the playing field again. Your competition isn’t building this.

If you and your competitor are building the same product, but you are using a loop and they aren’t, you’ll destroy them. You’ll be able to build 24/7/365 while they can only ship while they are at their keyboard.

You need to RIGHT NOW drop what you’re doing and start developing this system. Even if you’re just talking to your Hermes Agent or your Claude app on your phone

The game pieces moved. The battlefield shifted. Just using AI is no longer an advantage. Fable has made it too easy.

Now you need to automate.

3 days ago I thought loops were impossible. Now I think they’re mandatory.

I’d do this:

1. Go to your agent
2. Explain what you’re building
3. Ask what system you can build and which tools do you need to create an automated loops that continuously ships and reviews code.
4. Use the latest models. Ideally Fable 5, but GPT 5.5 if you need to.
5. Build out whichever plan they give you. Use it over and over. Each time you use it, find a part of it to tweak, fix, or improve.
6. The more you use the loop, the better it will get.

Most important AI project you can be implementing right now. Will 1000x the work you do moving forward. Will also give you a leg up on the battlefield.

Time to act.

[CooperBaggs 💰🍞 @edgaralandough]

ADHD EXPERIENCES THAT FINALLY HAVE NAMES:

1. Body doubling — you can't start alone, but with someone nearby, it happens.

[elvis @omarsar0]

Every CEO and every engineer should be strategizing carefully to avoid AI model lock-in.

More here:

https://t.co/QqTnlaaPH3

[Lance Martin @RLanceMartin]

https://t.co/es0JQM4MS9

[Akshay 🚀 @akshay_pachaar]

about loop engineering.

everyone's saying the same thing this week. you don't prompt agents anymore, you design loops that prompt them.

here's the job that loop hands right back to you.

a loop running unattended is also a loop failing unattended.

loop engineering takes you off prompting. it takes you off curating context. it takes you off babysitting a single run. it does not take you off debugging. it just moves the debugging somewhere worse, into runs you were never watching, with far too much of it to read through by hand.

even the loop engineering posts admit this themselves, usually somewhere near the end. you can only walk away from a loop if you trust the thing checking it. a checker you don't trust drops you right back into reading every output by hand, which is the exact work the loop was supposed to take off you.

so stack the layers up, prompt, context, harness, loop, and one job survives all of them. closing the loop on failure. the leverage point moved. debugging stayed exactly where it was.

i was writing about this exact gap yesterday, before the loop talk picked up today. the idea was simple. make debugging its own loop. a failure leads to a root cause, a proposed fix, a rerun against the exact inputs that broke, and a test that locks it out for good. the checker gets built from your real failures instead of guessed at up front.

Opik, the tool i was writing about, does exactly this. a built-in agent reads the trace, finds the root cause, proposes a diff, you approve it, and that failure becomes a permanent regression test. every break you debug makes the loop a little harder to break next time, which is the kind of checker the loop engineering crowd keeps saying you need before you walk away.

if you're designing loops you actually plan to walk away from, it's worth a look.

Opik is 100% open-source under Apache-2.0 license.

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

(don't forget to star 🌟)

loop engineering moved the leverage point. it didn't remove the engineer who still has to close the loop when something breaks.

the full article, Your Agent Harness Should Repair Itself, is quoted below.

[Zynd AI @zyndai]

https://t.co/oBQFk639hL

[How To Prompt @HowToPrompt__]

Stanford + Meta just dropped the paper that flips everything about AI agents.

It's called "Code as Agent Harness."

Right now, we treat large language models as text generators. When they need to solve a complex problem, they rely on a "chain of thought."

But natural language is slippery. It's vague. It loses context. When an agent hallucinates in English, it just keeps talking.

So they introduced a framework that changes the entire architecture of autonomy: "Code as Agent Harness."

They stopped asking the AI to reason in words, and forced it to reason in code.

Code isn't just the final output anymore. It is the memory. It is the environment. It is the boundary.

Instead of writing a paragraph about how to solve a problem, the agent writes a script, executes it, and reads the output.

Tests become its senses. Execution logs become its memory. Sandboxes become its physics.

If an agent makes a mistake in English, it apologizes and hallucinates again.

If an agent makes a mistake in code, the compiler throws an error. The trace tells it exactly what broke. The system forces it to fix it.

This is where prompt engineering dies, and systems engineering takes over.

The paper proves that reliability doesn't come from a smarter base model. It comes from the "harness" wrapped around it:

- The model proposes.
- The harness executes.
- The environment returns feedback.
- The verifier checks.

[diva @divaagurlxw]

As an AI Engineer. Please learn

>Harness engineering, not just prompt engineering

>Context engineering, not just long prompts

>Prompt caching vs. semantic caching tradeoffs

>KV cache management, eviction, reuse, and memory pressure at scale

>Prefill vs. decode latency and why they optimize differently

>Continuous batching, paged attention, and throughput optimization

>Speculative decoding vs. quantization vs. distillation tradeoffs

>INT8, INT4, FP8, AWQ, GPTQ, and when quantization hurts quality

>Structured output failures, schema validation, repair loops, and fallback chains

>Function calling reliability, tool contracts, argument validation, and idempotency

>Agent guardrails, loop budgets, tool budgets, and termination conditions

>Model routing, graceful fallback logic, and degraded-mode UX

>RAG architecture: chunking, embeddings, hybrid search, reranking, and freshness

>Retrieval evals: recall, precision, grounding, attribution, and citation quality

>Evals: golden sets, regression tests, adversarial tests, LLM-as-judge, and human evals

>LLM observability as a first-class discipline: traces, spans, tokens, latency, errors, and drift

>Cost attribution per feature, workflow, tenant, and user journey not just per model

>Safety engineering: prompt injection defense, data leakage prevention, and permission boundaries

>Multi-tenant isolation, cache safety, and cross-user context contamination prevention

>Fine-tuning vs. in-context learning vs. RAG vs. distillation and when each is the wrong tool

>Latency, quality, cost, and reliability tradeoffs across the full inference stack

>Production failure modes: hallucinated tool calls, malformed JSON, stale retrieval, runaway agents, and silent eval regressions