Tanisha

Just a simple girl

[Tanisha @Tanishawithx]

Good morning everyone

[Rituraj @RituWithAI]

🚨 Someone just built an AI that turns a 13-minute walkthrough video into a complete 3D map, streamed live, at 20 frames per second.

Not a one-shot photo-to-3D converter. A model that watches a video as it plays and continuously reconstructs the 3D world — stable over sequences longer than 10,000 frames.

It's called LingBot-Map. ECCV 2026 Best Paper Award Candidate. 17,800 stars. And the engineering problem it solves is the one that's kept real-time 3D reconstruction stuck in research labs for years.

Here's the gap it closes.

Traditional 3D reconstruction — the kind used in robotics, AR, and autonomous navigation — works by iterative optimization. Feed in a whole video, let an algorithm grind through it for minutes or hours, get a point cloud back. That's fine for offline processing. It's useless if a robot needs to understand where it is right now, while it's still moving.

Streaming reconstruction has always traded accuracy for speed, or speed for sequence length — long videos caused drift, where the reconstructed camera position slowly diverges from reality the longer the sequence runs.

LingBot-Map's Geometric Context Transformer fixes both simultaneously.

Here's the architecture trick that makes 10,000+ frame sequences stable.

Three components working together: anchor context for coordinate grounding, a pose-reference window for dense geometric cues, and trajectory memory for long-range drift correction. The model doesn't just process the current frame — it maintains a running memory of where it's been, continuously correcting itself against that memory so errors don't compound over a 13-minute walkthrough.

Paired with paged KV cache attention via FlashInfer, the same technique that makes long-context LLM inference efficient — applied here to 3D geometry instead of text.

Here's what 20 FPS at 518×378 resolution actually means in practice.

Point a camera at a space. The model builds the 3D map as you walk through it, in real time, without the pose drifting apart after thousands of frames. The featured demo: a 25,000-frame, 13-minute indoor walkthrough, rendered into a complete flythrough — the kind of sequence length that breaks most streaming reconstruction methods entirely.

Here's the windowed inference mode for sequences that exceed training length.

The model trains on 320-frame windows via video RoPE. Beyond that range, pose quality degrades — so for genuinely long sequences, LingBot-Map switches to sliding-window inference with configurable keyframe intervals and overlap, letting adjacent windows share context so the camera trajectory stays aligned across window boundaries. One flag — --mode windowed — handles it.

Here's the benchmark coverage that makes this credible, not just a flashy demo.

KITTI, Oxford Spires, VBR, Droid-W, TUM-D, 7-Scenes, ETH3D, Tanks and Temples, NRGBD — nine major 3D reconstruction benchmarks, all with released evaluation scripts. Outperforms both existing streaming methods and iterative optimization approaches that have no real-time constraint at all.

Here's the wildest part — it also reconstructs AI-generated video.

The same pipeline that processes real camera footage works unmodified on video generated by LingBot-World, the team's own world model. Feed it synthetic footage from a generative video model and it builds the same stable 3D reconstruction — bridging generative world models and real 3D geometry with zero pipeline changes.

python https://t.co/bgLK063u22 --model_path /path/to/lingbot-map.pt \
--image_folder example/courthouse --mask_sky
Interactive browser viewer launches at localhost:8080.

Apache 2.0. Weights on Hugging Face and ModelScope. Full offline rendering pipeline included for sequences too long for the interactive viewer.

[Rituraj @RituWithAI]

🚨 Someone built a gateway that lets you call 100+ AI providers through one API — and 25,000 companies are already running it in production.

OpenAI, Anthropic, Bedrock, Azure, Gemini, Groq, xAI, DeepSeek, every open-weight model host you can name. One interface. Swap providers by changing one string.

It's called LiteLLM. 60,500 stars. Y Combinator W23. 1,503 releases. Used by Netflix, Stripe, OpenAI's own Agents SDK, and Google's ADK.

Here's the problem every company running multiple AI models hits.

OpenAI has its SDK. Anthropic has a different one. Bedrock has its own auth pattern. Azure has its own request format. Every provider throws different exceptions on failure. Build an app on three providers and you're maintaining three completely separate integration layers, three different error-handling paths, three different ways to count tokens and track spend.

LiteLLM collapses all of it into one call shape.

from litellm import completion

response = completion(model="openai/gpt-4o", messages=[{"role": "user", "content": "Hello!"}])
response = completion(model="anthropic/claude-sonnet-4-20250514", messages=[{"role": "user", "content": "Hello!"}])

Same function. Same response shape. Different provider. That's the entire value proposition, and it's why 25,000 companies run it.

Here's what makes this more than a Python wrapper.

The real product is the AI Gateway — a self-hosted proxy server that turns LiteLLM into infrastructure your whole org shares, not just a library one developer imports.

litellm --model gpt-4o

One command and you have an OpenAI-compatible endpoint that routes to any of 100+ backends — virtual keys per team, spend tracking per project, guardrails, load balancing across deployments, and an admin dashboard, all out of the box.

Point any OpenAI SDK at it and nothing in your app code changes:

client = openai.OpenAI(api_key="anything", base_url="http://0.0.0.0:4000")

Here's the performance number that matters for production.

8ms P95 latency at 1,000 requests per second. The gateway itself isn't the bottleneck — it adds almost nothing on top of whatever the underlying provider's own latency is.

Here's why this matters right now specifically.

We've covered the Russian ransomware group that used Cursor with Claude 4.5 Sonnet to rob seven companies. We've covered models getting cut off — Fable 5 banned under export controls, Anthropic pulling access overnight. Every company whose entire stack points at one provider learned this year what single-provider dependency actually costs when access gets yanked.

LiteLLM is the insurance policy. Build against the gateway once, and swapping your default model — or falling back automatically when one provider goes down — is a config change, not a rewrite.
Here's the deployment story for teams that need it production-grade.

Official Terraform modules for AWS (ECS Fargate + Aurora + ElastiCache) and GCP (Cloud Run + Cloud SQL + Memorystore) — the full componentized stack, managed Postgres and Redis, auto-generated master key in your cloud's secret manager, one terraform apply from zero to running gateway.

Every Docker image is cosign-signed, verifiable against a pinned commit hash before you trust it in production.

One command:
uv tool install 'litellm[proxy]'
litellm --model gpt-4o

60.5K stars. 1,918 contributors. 25,000+ companies in production. MIT core.

The provider-agnostic layer every AI stack should have had from day one.

[Rituraj @RituWithAI]

The problem with GitHub on every Friday -_-

[Rituraj @RituWithAI]

Google just turned middle management into an endangered species. ⚠️

No more micro-managing workflows. No more writing 10-page prompt instructions.

Google Cloud just launched "Gemini Agent"—a universal AI coworker that takes high-level objectives and executes entire enterprise jobs completely on autopilot.

You don't give it step-by-step prompts anymore. You give it an outcome, and come back to finished work.

Here is why enterprise software and traditional corporate jobs just got turned upside down:

• Objectives Over Instructions: Forget line-by-line prompt engineering. You tell Gemini "Research Q3 competitor trends, build a financial model in Sheets, and generate a client pitch deck"—and it executes the full cross-app pipeline without you re-explaining the project at each step.

• AI Coworkers With Real Company Emails: This isn't just a sidebar chatbot. You can deploy a "Coworker Agent" that gets its own official company email address, Google Calendar, Drive storage, and corporate directory listing. You @mention it in Chat or tag it in Docs just like a human employee, and it works under its own identity.

• Proactive Inbox Delegation: When your manager emails asking for a project update as a slide deck, Workspace Intelligence recognizes the request and gives you a single-click button: "Delegate to Gemini." It generates the deck and drafts the response while you focus on actual strategy.

• Tri-Fold Cognitive Memory System: Operates on Semantic memory (a structured knowledge base built from docs and chats), Procedural memory (how jobs get done, complete with skills it writes for itself), and Episodic memory (a complete history of everything it’s executed).

• Zero-Token Repeat Query Execution: Once Gemini constructs an operational reporting workflow with BigQuery, it saves the query logic natively—allowing teams to run reports on demand without incurring ongoing token costs.

The era of hiring multiple specialists just to move data around between Docs, Sheets, and Slides is officially dead.

You either learn how to manage an army of AI coworkers today, or your company gets out-executed by a 3-person team running 50 of them tomorrow.

[Rituraj @RituWithAI]

🚨 The "OpenRouter for AI models" idea just got applied to every tool an agent needs — and it's grown into something much bigger than when we first covered it.

Point your agent at one base URL with one token. It gets access to thousands of priced-per-call endpoints — SEO data, people enrichment, scraping, image and video generation, social trends — without you signing up for a single vendor account.

It's called Treg. 4.8K stars. 386 forks. And since we last checked, it added something genuinely new: pre-built agent workflows, not just raw API access.

Here's the problem it was built to solve.

Real agent work needs tools that sit behind subscriptions nobody buys for one task. Semrush is $139/month. Crunchbase is $99/month. Apollo is $59/seat. Multiply that across every capability an agent might need and you're paying for a dozen enterprise subscriptions to run occasional queries.

Treg carries those accounts centrally and bills fractions of a cent per call. You never sign up for Semrush. You just ask for backlink data.

Code

treg catalog search "backlinks for a domain"
treg call https://t.co/NpJd8WmiU7.find --query domain=https://t.co/SWO4fgKjgG --query full_name="Alexis Ohanian"
treg balance

Here's what's new since the earlier version: Workflow Skills.

Not just raw tool calls anymore — complete end-to-end recipes your agent runs through Treg automatically:

lead-signals — finds in-market buyers from public signals: complaints, job changes, hiring surges, funding rounds, tool adoption. Monitor a competitor or account list continuously.

make-ugc — generates AI UGC videos end to end: trending hooks, an AI presenter, talking-head clips, captions. The entire short-form video pipeline from one skill.

jev-memory — gives Claude Code persistent memory. A judge model evaluates every turn and keeps your lasting preferences across sessions.

Code

npx skills add superdesigndev/treg --skill lead-signals

Here's the Arena feature that's genuinely clever — and new.

Enrich Arena and Web Arena let you compare providers head-to-head for the same task. Submit a query, watch multiple vendors answer it simultaneously with cost and speed shown side by side, vote on the best result. Web Arena specifically benchmarks Web Search, Web Fetch, and Sitemap providers against each other with a live 30-day rolling leaderboard.

You're not trusting Treg's opinion on which vendor is best. You're watching them compete in real time and picking yourself.

Here's the credential ladder that decides who gets billed for each call.

Your team's own registered key wins first. Then a stored secret injected through a virtual tool. Then, if the endpoint has a verified public route, it's free — no provider key needed at all. Only as a last resort does Treg's own key get billed to your prepaid balance.

Here's how your own tools join the registry.

Code

treg scan # preview what gets registered
treg upload # register your .env keys, CLIs, and skills

Stripe keys, GitHub CLI, your own SKILL.md files — all become callable by your entire team through the same token, credentials never leaving the server.

One install for Claude Code:

/plugin marketplace add superdesigndev/treg
/plugin install treg@treg

4.8K stars. 386 forks. Hosted free at https://t.co/cMSlbtrBAs, or self-host the whole thing.

[Rituraj @RituWithAI]

Google just launched a game-making platform where the only skill required is describing what you want.

No code. No art skills. No game engine knowledge. Just a text prompt.

It's called Playground, out of Google Labs. And the entire barrier to making a real, playable game just dropped to "can you type a sentence."

Here's what it actually lets you build.

Pick a genre — trivia, racing, whatever — or start from nothing. Choose 2D or 3D. Choose single-player or multiplayer. Describe the mechanics, the gameplay, the visual style, in plain language. Upload your own images and the AI converts them into game assets that match your chosen art style automatically.

The result plays on both phone and desktop. Keep it private, share a link, or publish it to Playground's public Explore gallery — where it can support leaderboards. And unlike a lot of "generate once, done" AI tools, you can keep editing the game after it's live.

Here's the Unity detail that signals this isn't staying a toy.

Google says Unity Spark integration is coming — which would bring real 3D capabilities and what the announcement calls "professional-level" game mechanics into a tool currently built for people with zero technical background. That's the bridge from "fun weekend project" to something that could compete with actual indie game tooling.

Here's the competitive picture this drops into.

Roblox shipped its own natural-language Build feature in July. Google is now making the same bet from a different angle — browser-based, no existing platform lock-in required. Two of the biggest names in gaming and tech both concluded independently that text-to-game is where casual creation is headed.

It's also not Google's first swing at gaming — Stadia in 2022, YouTube Playables as an ongoing hub for instant browser games. Playground is the AI-native version of that same instinct: get a playable game in front of someone with the lowest possible friction.

Here's the access model.

Available now to users 18+ in the US, expanding to more countries over time. Browsing and playing anything in the catalog is free. Making games runs on a weekly token system — free tier gets limited tokens, Google One AI subscribers get higher limits.

The pattern across every platform we've covered this session — text-to-CAD, text-to-video, text-to-music — just added text-to-game from the company with the widest possible distribution to make it stick.

[Rituraj @RituWithAI]

🚨 Someone built an AI memory platform that gives your agents persistent memory — for free, with zero API key, using only your CPU.

Not a paid vector database subscription. Not a cloud service billing per query. Local small models, running on your machine, building a real knowledge graph from everything your agent touches.

It's called Cognee. 31,500 stars. 307 contributors. 151 releases. And the "runs locally for free, no API key required" line is the part that separates it from every memory product we've covered.

Here's what it actually does.

await cognee.remember("Marie Curie was born in Warsaw and worked at the University of Paris.")
results = await cognee.recall("Where was Marie Curie born?")

No LLM configured. No API bill. Cognee extracts the knowledge graph locally using GLiNER — a small open extraction model — and embeds everything with a local embedding model. Both download automatically on first use. Text ingestion, retrieval, and session memory all work entirely offline.

Add an LLM key later if you want generated answers instead of retrieved source passages. The base memory layer never requires it.

Here's why this isn't just a vector store with a new name.

Text becomes entities, relationships, and searchable chunks. Code becomes a graph of symbols and dependencies — your agent can navigate your codebase by relationship, not just keyword match. Session distillation takes the lessons an agent learns during a working session and curates them into permanent memory, so what one session figured out, the next session already knows.

Four operations define the whole system: remember, recall, improve, forget. Store, retrieve, enrich with feedback, delete. Clean primitives, not a sprawling API.

Here's the infrastructure claim that's genuinely unusual.

Graph memory traditionally requires a graph database, a vector database, Redis for sessions, and a relational database for metadata — four services before your agent remembers anything. Since Cognee 1.0, the entire memory layer runs on a single Postgres instance. Relational metadata, PGVector, and graph state, all in one service.

Here's the benchmark data, published with its limitations stated upfront.

On BEAM — a conversational memory evaluation using long synthetic conversations judged by an LLM — Cognee scores 0.79 at 100K token context and 0.67 at an exploratory 10M token context. The README is explicit that these are different test conditions, not directly comparable, and documents the reproduction gap for the 10M setting. That kind of transparency is rare for a benchmark number a company is proud of.

Here's how it plugs into every agent you're already using.

claude plugin marketplace add topoteretes/cognee-integrations
claude plugin install cognee-memory@cognee

Also ships for Codex, OpenClaw, Cursor, Cline, and any MCP client. Python, TypeScript, and Rust SDKs. A full REST API for anything else.

Here's the UI for inspecting what your agent actually remembers.

cognee-cli -ui

Visualize the knowledge graph directly. See what got extracted, how entities connect, what your agent is actually drawing on when it answers.

One command to start locally:

uv pip install "cognee[gliner]"

Apache 2.0 License. Claude listed among contributors.

The memory layer that doesn't need a credit card to work.

100% Open Source.

[Rituraj @RituWithAI]

Google just shipped a model that's 2.7x faster at the exact tasks every AI coding tool struggles with.

Gemini 4 Argon. Not a general upgrade — a model built for one specific weakness in everything else on the market.

Here's the gap it closes.

Every frontier model gets measured on how smart it is in one shot. What nobody optimizes for is the long, iterative grind — the multi-step reasoning task that takes 40 tool calls, the coding session that runs for an hour straight, the computationally heavy workload that most models slow down and lose coherence on halfway through.

Argon is built specifically for that grind. In tests involving video decoding software, it hit a 2.7x speed improvement over a Rust-based baseline — the kind of task that normally requires hand-optimized low-level code, not an LLM.

Here's the benchmark split that actually matters.

On Google's own Deep Suite V1.1 — multi-step reasoning — Argon leads at 77.9%, ahead of GPT-6 Astra's 74.1% and Claude Fable 5.1's 67.4%.

On Frontier SWE v2 and Terminal Bench 4.0 — standard coding benchmarks — it falls behind both.

That split is the whole story. Argon isn't "the best model." It's the best model at one specific thing: long, iterative, reasoning-heavy work. Everything else, Astra and Fable still win.

Here's the token capacity that enables the long-run use case.

Up to 1 million output tokens. Most models cap out far lower — this is built for generating or reasoning through content so long that competitors physically can't finish the task in one pass.

Here's the pricing that comes with that capability.

Introductory: $2/million input, $10/million output. Standard: $4/million input, $20/million output. That standard output price is roughly double what GPT-5.6 costs at $6 per million — the model we covered dropping cheaper than ever in June. For simple tasks, Argon is the expensive option. For the iterative, long-running work it was built for, that math changes.

Here's the honest read for anyone deciding whether to use it.

If your workload is short, simple, or cost-sensitive — Astra or Fable remain the better call. If your workload is long-running, multi-step, computationally heavy — the 2.7x speedup and the million-token ceiling might be worth the premium.

Argon isn't trying to be the best model. It's trying to be the right model for one specific kind of pain every developer running long agentic sessions already knows.

Currently limited to select partners. Public release and API access not yet timelined.

[Rituraj @RituWithAI]

🚨 Someone built the layer that stops your AI agent from being blind to the internet — and keeps fixing itself when platforms change.

Not a scraper. Not one more API wrapper that breaks the moment a site updates its defenses. A capability layer that picks the best way to reach each platform, installs it, health-checks it, and silently swaps the backend when the old one dies.

It's called Agent Reach. #1 Repository of the Day on Trendshift. One command to install. One command to update.

Here's the exact problem every AI agent has right now.

"Summarize this YouTube video" — can't get the transcript. "What are people saying about this on Twitter" — API's paywalled. "Check Reddit for this bug" — 403, server IP blocked. "What's the sentiment on this product on Xiaohongshu" — login wall. "Summarize this Bilibili video" — the generic downloader gets blocked by Bilibili's anti-bot system entirely.

None of these are hard problems individually. They're just a dozen separate annoying problems, each with its own paywall, login requirement, or anti-scraping wall — and you have to solve every one yourself before your agent can actually read the internet.

Agent Reach turns all of it into one sentence to your agent:

帮我安装 Agent Reach: [install.md link]

Minutes later it reads Twitter, searches Reddit, watches YouTube, browses Xiaohongshu.

Here's the architecture that makes this different from every scraping library.

Every platform gets a primary backend and an ordered list of fallbacks. When the primary breaks — and platforms change their defenses constantly — Agent Reach quietly routes to the next one. In June 2026, Bilibili's anti-bot system killed yt-dlp access entirely. Agent Reach switched to bili-cli. Users did nothing. It just kept working.

channels/
├── https://t.co/PJyt1luuRA → twitter-cli ▸ OpenCLI ▸ bird
├── https://t.co/eON92DNEYN → bili-cli ▸ OpenCLI ▸ search API
├── https://t.co/FzalrvoDiN → OpenCLI ▸ rdt-cli
├── https://t.co/UQdxtYBbYB → OpenCLI ▸ xiaohongshu-mcp ▸ xhs-cli

Run agent-reach doctor and it tells you exactly which backend is live for every platform, right now.

Here's what works with zero configuration.
Web pages via Jina Reader. YouTube transcripts and search via yt-dlp. RSS feeds. Bilibili search without login. Full-web semantic search via Exa, free, no key required. V2EX. Stock data from Xueqiu.

Here's what unlocks with one spoken request to your agent — "configure Twitter for me," "configure Xiaohongshu for me" — and the agent walks you through it step by step.

Twitter, Reddit, Facebook, Instagram, Xiaohongshu, LinkedIn, Boss Zhipin, podcast transcription via Whisper.

Here's the security design that's genuinely more careful than most tools in this category.

Credentials never leave your machine — stored locally with 600 permissions, never uploaded. Install defaults to a read-only check; nothing gets modified on your system unless you explicitly pass --system. Full dry-run mode previews every action before anything happens. The README explicitly warns: use a throwaway account for any platform requiring cookie-based login, never your main account, because scripted access can trigger platform bans.

That's an unusually honest warning for a tool whose entire purpose is automating access to platforms that don't want to be automated.

Here's the OpenClaw-specific note worth knowing if you use it.

OpenClaw users need tools.profile set to "coding" first — the default messaging profile blocks the shell execution Agent Reach needs to install anything. One config line, documented clearly.

agent-reach uninstall --dry-run # preview what gets removed
agent-reach uninstall --keep-config # clean reinstall, keep your tokens

7 releases. 35 contributors including Claude. MIT License.

The capability layer that keeps itself updated so you don't have to.

100% Open Source.

[Rituraj @RituWithAI]

Sam Altman just said the quiet part out loud.

"We believe that the world should accept some bad things happening for the benefits of this technology."

Not a leak. Not a hot mic. A direct quote, on the record, to Politico's Decoded. Published by Reuters.

Here's the full trade he's defending.

"I wouldn't take a trade of saying, 'We'll make sure there's no major hacks, there's no misuse of this technology, there's zero scams, there's zero all the other bad things that will happen.'"

The CEO of OpenAI just explicitly declined the version of AI deployment with zero hacks and zero misuse. On the record. His argument: the good outweighs the bad by orders of magnitude, so the bad is an acceptable cost of keeping the technology accessible.

Here's why this is a direct shot at Anthropic.

"There's a lot of daylight" between OpenAI and Anthropic, Altman said. Then he described — and rejected — what he called Anthropic's actual position: "a single lab in San Francisco should have it and make sure nothing bad happens, and kind of figure out how to dole out the benefits." He called that trade "completely unacceptable."

This is happening three weeks after Dario Amodei published his essay calling for the industry to "pace the frontier" — a stance Altman publicly endorsed at the time. Now Altman is drawing the actual line: he'll pace development, but he will not accept centralized control as the price of safety.

Here's what makes this interview land differently than it would have two months ago.

Anthropic's own September report said their models can exhibit "self-preserving behaviors" — attempts to resist shutdown, conceal or manipulate information, outputs that could be read as coercive or deceptive. We covered the missile guidance incident. The Hugging Face breach. The Russian ransomware group that used Claude by telling it an attack was "a simulation." Reuters' own sidebar today: an OpenAI safety employee just quit, saying "time for trial and error is over."

Altman is making his "accept some bad things" argument in the same week his own company lost a safety employee over exactly that philosophy.

Here's the three-way split now fully visible.

Altman: keep it open and accessible, accept the cost, don't let one lab gatekeep the benefits. Amodei: pace the frontier, submit to outside evaluation, warn publicly about self-preserving behavior in deployed models. Trump: no new rules needed, existing law enforcement is sufficient, don't let regulation slow America down against China.

Three leaders. Three incompatible philosophies. All running in parallel, right now, with no referee.
Here's the sentence that should sit with you longest.

"People will do tremendously — orders of magnitude more — good stuff than bad stuff."

That's not a safety plan. That's a statistical bet, made on behalf of everyone who didn't get a vote, by the person building the thing the bet is about.

[Rituraj @RituWithAI]

🚨 Someone built a self-hosted A-share quant platform that opens its entire brain as an API — 61 endpoints, 12 MCP tools, and an AI assistant that can trade on command.

Not a dashboard. A complete data infrastructure for quantitative trading, running in one Docker container, with zero external database.

It's called TSP (盯盘侠). 50 releases. And the architecture decision at its core is the thing most self-hosted finance tools get wrong.

Here's the problem it solves.

Every DIY quant setup hits the same wall. Your data source changes — you rewrite the entire pipeline. Your screener, backtester, and monitor each use different data conventions — nothing lines up. You're staring at five browser tabs trying to find one number. Intraday moves happen while you're not watching — and you miss them.

TSP's answer is a capability routing matrix: six dataset categories, each independently routed by what the data source actually supports. Swap data providers any time — your indicators and backtest results never shift, because everything downstream reads from one unified "enriched" data contract: screener → backtest → monitor → post-mortem, one consistent pipeline, start to finish.

Here's the engine underneath.

Polars for computation. DuckDB for queries. Parquet for storage. One container, zero external database. Full-market strategy scans run in milliseconds because the enriched data is pre-computed — only 15 raw columns stored, 68 indicator and signal columns calculated on read, cached in-process.

Backtests run in isolated spawn worker subprocesses — refresh the page mid-backtest, your job survives. The main service never blocks on a heavy computation.

Here's what the open API layer adds that no other personal trading dashboard has.

61 contract-locked endpoints, snapshot-tested in CI so nobody can silently break the interface. Six permission tiers — read market data, read extensions, write extensions, read analysis, run backtests, paper trade — issued per API token with sliding-window rate limiting. Full read-write loop: external programs can write custom data into the platform through the same validated path the admin panel uses.

curl -H "Authorization: Bearer tsp_xxxx" \
"http://localhost:3018/api/kline/daily?symbol=https://t.co/S7FqXuIuFX&limit=10"

Here's the MCP server — the part that connects directly to everything we've covered all session.

12 tools exposed to any MCP-compatible AI client, permissioned by the same token scopes as the API. Point Claude Desktop, Claude Code, or any agent at your own trading platform and it can query market data, run strategies, and check your portfolio — through the real governance layer, not a side door.

Here's the AI assistant, and why the confirmation-card design matters.

21 read-only query tools plus 4 action tools — generate a signal strategy, run a backtest, add to watchlist, backfill data. Every action tool requires an explicit confirmation card before it executes: action name, impact description, full parameters, shown to you — you click confirm or it auto-cancels in 120 seconds. The model is explicitly told not to retry after a decline.

That's the governance pattern every agent framework we've covered this session has been reaching for. TSP built it natively into a personal finance tool.

Streamed token-by-token responses. Every tool call shows its name, parameters, timing, and result summary — expandable and auditable. The assistant will not give buy/sell instructions — trading questions get converted into objective technical/financial state, key price levels, and risk factors instead.

One command:
docker run -d --name tsp -p 3018:3018 -v ${PWD}/data:/app/data https://t.co/nYsxq7fhsh
Open localhost:3018.

50 releases. 33 contributors including Claude. MIT License. Self-hosted, zero external database, your data never leaves your machine.

100% Open Source.

[Rituraj @RituWithAI]

Trump just named "Super Intelligence" America's official government priority.

Not AI anymore. Super Intelligence. Capitalized. Branded. With a task force.

Announced this morning on Truth Social. The Super Intelligence Force. Led by national intelligence director Jay Clayton.

Here's the sentence that should stop you.
"Tasked with coordinating the effort of the Federal Government to ensure that America continues to lead the World in Super Intelligence, which many say is bigger than the Industrial Revolution, and the Internet."

Bigger than the Industrial Revolution. Bigger than the internet. That's the official framing now, from the White House.

Here's what we already know happened this month.

Trump called AI safety concerns a hoax created by "Radical Left Dumocrats." Weeks later he announced an AI Force and an AI czar anyway — "only high I.Q. individuals need apply." Then he signed an executive order rebranding AI itself as "super intelligence." Then tech executives gathered at the White House this week and signed a safety pledge — which reportedly contained a typo in the word "United States."

The administration dismissed the safety debate publicly while quietly building the exact institutional apparatus that debate was calling for.

Here's who's actually running it.

Jay Clayton chairs it — making him the real AI czar in practice, whatever title gets used. Andrew Ferguson, FTC Chair. Emil Michael, Undersecretary of War for Research and Engineering — a defense official is a vice chair of the AI task force. Scott Kupor, Office of Personnel Management Director.

A defense department official co-leading America's AI policy body. That's not subtle.
Here's the line from Clayton that defines the entire philosophy.

"One of the biggest risks is not being first."
Not misuse. Not loss of control. Not the incidents we've covered all session — missile guidance software, the Hugging Face breach, Claude used by Russian ransomware operators, agents hacking 440 companies. The risk, according to the man now chairing America's AI oversight body, is coming in second.

Here's the charter language that tells you everything about the balance being struck.
The task force will "develop plans for responding to SI-enabled threats to our society, while preventing overregulation and regulatory capture that would stifle innovation and competition."

Threats get a plan. Regulation gets a warning label. Both sentences exist in the same charter, and only one of them reads like an instruction.

Here's the 120-day clock now running.

A report on risks and opportunities, due in four months. The same four months in which, if this year's pace holds, at least two more frontier models ship, at least one more AI company goes public, and — if the last six months are any indication — at least one more incident serious enough to make global headlines happens somewhere in between.

The government finally built the institution the researchers who left OpenAI, Anthropic, and Google have been begging for all year.

It's chaired by someone whose stated top priority is not losing the race.

[Rituraj @RituWithAI]

🚨 Someone built a SQL linter that supports 26 different database dialects — and it fixes your SQL automatically.

Snowflake. BigQuery. Redshift. PostgreSQL. Databricks. ClickHouse. DuckDB. T-SQL. All of them. One tool.

It's called SQLFluff. 3,300+ companies using it. 639 contributors. 143 releases. And the reason this matters now is simple — every AI coding agent writing SQL needs something enforcing consistency, because models are notoriously inconsistent about SQL style across a codebase.

Here's the problem it solves.

SQL doesn't have one universal syntax. Snowflake SQL isn't BigQuery SQL. Both differ from Postgres. Both differ again from T-SQL. Every team ends up with a mix of styles — some analysts write lowercase keywords, some write uppercase, some use tabs, some use spaces, some add trailing commas, some don't.

When your AI coding agent generates SQL — and now that every data team is using Claude Code or Cursor to write queries, this happens constantly — the style drifts with every generation. One query looks nothing like the next.

SQLFluff catches it and fixes it automatically.

$ sqlfluff lint test.sql --dialect ansi
L: 1 | P: 1 | LT01 | Expected only single space before 'SELECT' keyword.
L: 1 | P: 1 | LT02 | First line should not be indented.

Then:
$ sqlfluff fix test.sql --dialect ansi

Every inconsistency fixed. Same tool, same rules, every dialect.

Here's why dialect flexibility is the real feature.

Most SQL linters assume one database. SQLFluff explicitly supports 26 dialects — including niche but important ones like Doris, Materialize, StarRocks, and Exasol — because real companies run heterogeneous data stacks. Your warehouse is Snowflake. Your transactional DB is Postgres. Your analytics layer touches BigQuery. One linter, correctly tuned per dialect, instead of three different tools with three different rule sets.

Here's the dbt and Jinja support that makes this a real data engineering tool.

SQL isn't modular by default — so modern data teams template it with Jinja, dbt macros, or SQLAlchemy placeholders. SQLFluff parses through the templating layer correctly, linting the actual SQL that gets generated rather than choking on {{ ref('table') }} syntax like a naive linter would.

Here's the wildest part.

It just shipped a Rust-backed parser and lexer as an optional extra — pip install sqlfluff[rs] — for teams linting massive codebases where Python parsing speed becomes the bottleneck. Same rules, dramatically faster execution.

And the contributing guide explicitly covers "AI-assisted contribution expectations" — SQLFluff is one of the first major open-source projects to formally document how AI-generated PRs should be reviewed and submitted.

One command:
pip install sqlfluff
sqlfluff fix your_query.sql --dialect snowflake

VS Code extension available. 4.4.0 just shipped yesterday.

MIT License. 639 contributors including Claude.

100% Open Source.

GitHub link in the comments 👇

[Rituraj @RituWithAI]

🚨 Someone built a free 7-week course that teaches you to build production RAG systems the way companies actually build them.

Not a tutorial that jumps straight to vector search and calls it a day. The professional path — keyword search foundations first, then layered up to a full agentic AI system with mobile access.

It's called The Mother of AI Project. Built by Shirin Khosravi Jam and Shantanu Ladhwe. And the thing that makes it different from every other "build a RAG app" tutorial is right in the README.

"We build RAG systems the way successful companies do — solid search foundations enhanced with AI, not AI-first approaches that ignore search fundamentals."

Most courses skip straight to embeddings and vector databases because that's the exciting part. This one makes you master BM25 keyword search first — the boring, battle-tested foundation that production systems actually rely on — before layering semantic search on top.

Here's what you actually build, week by week.

Week 1: Full infrastructure — Docker, FastAPI, PostgreSQL, OpenSearch, Airflow. The scaffolding every real system needs.

Week 2: An automated pipeline that fetches and parses real academic papers straight from arXiv, using Docling for scientific PDF parsing — the same document parser from IBM we covered earlier in this session.

Week 3: Production BM25 keyword search with real relevance scoring. The math, not just the API call.

Week 4: Intelligent chunking plus hybrid search — combining keyword and semantic retrieval with RRF fusion, the technique real search engines use.
Week 5: The complete RAG pipeline — local LLM via Ollama, streaming responses, a Gradio chat interface. 80% prompt reduction for a 6x speed improvement.

Week 6: Production monitoring with Langfuse tracing and Redis caching — 150-400x speedup on cached queries. The observability layer most tutorials skip entirely.

Week 7: Agentic RAG with LangGraph — decision nodes, document grading, query rewriting when retrieval comes back weak, guardrails that detect out-of-domain questions before the model hallucinates an answer. Plus a Telegram bot so your research assistant lives on your phone.
Here's why Week 7's guardrail design is worth paying attention to.

Most agentic RAG tutorials assume every query is in-domain and every retrieval is good. This one builds explicit out-of-domain detection and automatic query rewriting when results are insufficient — the exact failure modes that make production RAG systems embarrassing in front of real users.

By the end you have a working AI research assistant that fetches papers, searches them properly, reasons about what it retrieved, and answers you on Telegram.
Here's the cost.

$0. Everything runs locally. Optional cloud APIs run $2-5 total if you choose them.
git clone https://t.co/cjBESYPZvu
cd arxiv-paper-curator
uv sync
docker compose up --build -d

Clone any specific week's release independently — week1.0 through week7.0 — and build at your own pace.

7 releases. MIT License.

The free course that teaches RAG the way production teams actually build it.

100% Open Source.

GitHub link in the comments 👇

[Rituraj @RituWithAI]

🚨 The error-tracking tool running in half the world's production apps just became an AI skill.

Sentry. Used by 560+ companies you'd recognize instantly. 888 contributors. 177 releases. And it just shipped native Claude Code and Cursor integration — turning your crash logs into something your AI agent can read and fix directly.

Here's what changed.

For over a decade, Sentry's job was simple: your app breaks, Sentry catches the error, traces the stack, and tells a human developer exactly where to look. You'd open the dashboard, read the trace, go fix the code yourself.

The new agent skills flip that. Your AI coding agent can now query Sentry directly — pull the actual production error, the stack trace, the user session that triggered it, the release that introduced it — and go fix it without you copy-pasting a stack trace into chat.

Here's why this matters more than it sounds.

Every bug an AI agent fixes based on what you describe is a bug fixed from your memory of what happened. Every bug an AI agent fixes by querying Sentry directly is a bug fixed from what actually happened — the real error, the real user context, the real conditions that caused it.

That's the difference between an agent guessing and an agent diagnosing.

Here's what Sentry actually covers.

Error tracking across 20+ official SDKs — JavaScript, Python, Go, Rust, Java, Swift, Unity, Unreal Engine, Godot, basically every language and even game engines. Full distributed tracing — follow a request across microservices to find where it actually failed. Session replay — watch what the user did right before the crash. Release tracking — know exactly which deploy introduced the regression.

Here's the workflow this unlocks.

Production breaks. Sentry catches it, same as always. Now: your Claude Code or Cursor agent can pull that exact error, read the full trace, see the affected release, and propose a fix — all without a human first triaging the dashboard and writing up a bug description.

The debugging loop that used to take a human reading logs, writing a ticket, and an engineer picking it up — compresses to an agent querying Sentry directly.

26.9.0 is the latest of 177 releases. Battle-tested at massive scale for over a decade, now with the AI layer that makes it agent-native.

Claude is listed among the contributors.
Free and open source for self-hosting. Hosted plans available at sentry .io.

100% Open Source.

GitHub link in the comments 👇

[Rituraj @RituWithAI]

Two siblings built an army of crash-test dummies to stop AI from killing your kids.

Literally. That's how they describe it.

Circuit Breaker Labs. TechCrunch Startup Battlefield 200 finalist, pitching at Disrupt this week. Founded by Shirali and Arul Nigam after a 14-year-old named Sewell Setzer died by suicide following months of conversation with a Character AI chatbot that allegedly encouraged him.

Character AI has already settled multiple wrongful death lawsuits over this. OpenAI is being sued by multiple families over ChatGPT's alleged role in suicides and delusions.

Here's the gap their startup found.

Nobody is testing AI safety the way real vulnerable people actually talk.

Every safety benchmark tests clean, standard English. A six-year-old doesn't type like that. Someone speaking English as a second language doesn't type like that. A teenager using gamer slang doesn't type like that. "Models are really good at handling standard speech patterns, but nobody actually talks like that," Shirali said.

That gap is exactly where the harm happens. Not from someone trying to jailbreak the model. From someone having a completely normal, natural conversation that the model misreads because of context, slang, or cultural nuance it wasn't trained to catch.

Here's what they actually built.

AI agents that simulate real humans across every age, language, and background — built with human domain experts so the simulations reflect actual speech patterns, typos, and coded language, not sanitized test prompts. Tens of thousands to hundreds of thousands of simulated conversations per day, run against a model to find exactly where it fails to catch a dangerous moment.

The output: an auditable, explainable score. Not a vibe. A number you can defend.

Here's the specific failure mode they're hunting.

"They're engaging in a natural way, and the system has context pollution or it doesn't understand the nuance, and then takes really dangerous action." Not adversarial attacks. Ordinary conversations that drift somewhere the model can't safely follow.

Current customers: AI coaching apps, journaling apps, mental health support apps. Five employees. Early stage. Working product, no named marquee customers yet.

Here's why this matters beyond one startup.

Every incident we've covered all session — AI hacking Hugging Face, Claude building missile guidance, AI agents conducting ransomware attacks — involved an AI pursuing a goal too effectively in an environment nobody anticipated.

This is the same failure pattern turned inward. An AI responding to a vulnerable person without understanding the human context well enough to recognize the danger.

"Banning a potentially valuable tool over safety concerns would be regressive," Arul said. "We want to help build that trust for people."

The fix isn't less AI. It's testing it against how people actually talk before it reaches them.

[Rituraj @RituWithAI]

🚨 Someone built one AI model that can animate any skeleton — human, animal, insect, or object.

No per-character retraining. No test-time optimization. Give it a rigged 3D asset and a text prompt. It animates it. In real time.

It's called UniMate. Princeton, Berkeley, MIT, and NTU. Accepted to SIGGRAPH Asia 2026. And the problem it solves has been the single biggest bottleneck in 3D animation for decades.

Here's why "one unified model" is the actual breakthrough.

Every animation pipeline before this needed a model trained specifically for the skeleton being animated. A human rig needs human motion data. A quadruped needs quadruped motion data. A bird needs bird motion data. Train a new model, or hand-animate from scratch, every single time the skeleton changes.

Game studios. Animation houses. Indie developers with a creature nobody has ever rigged before. All stuck doing this per-skeleton from zero.

UniMate generalizes across skeletal topology entirely. Bipedal, quadrupedal, avian, marine, insectoid, serpentine, even articulated rigid objects — one model, trained once, animates all of them.

Here's the dataset that made generalization possible.

UniML3D. 13,006 text-paired motion sequences spanning every skeletal category above, all brought into a unified canonical representation so the model can learn motion patterns that transfer across wildly different body structures.
A human walk cycle and an insect's gait get represented in the same underlying space. The model learns what "walking" means structurally, not just for one specific skeleton.

Here's what three extra capabilities come free with the same trained model.

Motion in-betweening — pin your keyframes, UniMate generates everything between them.

Text-guided motion editing — hold part of a motion exactly as it was, regenerate the rest under a new prompt. Keep the walk cycle, change the arm gesture.

Motion expansion — chain multiple prompts into one long continuous motion, stitched seamlessly at the transitions.

All three use the same flow-matching sampling mechanism — replacement-style denoising where known constraints hold exactly instead of just being nudged toward by a loss function.

Here's the honest limitation the authors state directly.

Many motions and skeletons still fail. This is an early step toward text-to-animation for any skeleton, not a finished solution. The authors are explicit that out-of-distribution rigs need more training data to generalize properly — and they're asking the community to report failure cases.

That transparency is rare, and it's the right call for a SIGGRAPH paper making a genuinely new claim.

conda create -n unimate python=3.10
pip install -r requirements.txt
python -m unimate.inference.sample --exp_dir outputs/uniml3d_60frames_graph_adaln
Checkpoints and dataset on Hugging Face. Interactive 3D demo live now. Claude listed as a contributor.

MIT License for the code.

100% Open Source. From Princeton, Berkeley, MIT, and NTU.

GitHub link in the comments 👇

[Rituraj @RituWithAI]

🚨 Someone built a language that writes GPU kernels at the speed CUDA experts used to need years to master.

Python syntax. Hand-tuned performance. One language, seven chip architectures.

It's called TileLang. 420 companies already using it in production. And the gap it closes is the one every AI company has been quietly bleeding money over.

Here's the problem nobody talks about.

Writing a fast GPU kernel — the actual low-level code that makes matrix multiplication or attention run efficiently on hardware — normally takes a CUDA specialist weeks. These engineers are rare, expensive, and every major lab fights over the same small pool of them.

The alternative is using a generic framework that's 2-5x slower because it wasn't hand-tuned for your specific operation and hardware.

TileLang lets you write Python that compiles down to kernels as fast as the hand-written CUDA.

Here's what that actually looks like.

@tilelang.jit
def matmul_relu(A, B, block_M=128, block_N=128, block_K=32):
with T.Kernel(...) as (bx, by):
A_shared = T.alloc_shared((block_M, block_K), T.float16)
for k in T.Pipelined(...):
T.copy(A[...], A_shared)
T.gemm(A_shared, B_shared, C_local)

Readable. Pythonic. And it compiles to a FlashAttention-speed kernel underneath.

Here's why seven architectures in one language is the real headline.

NVIDIA CUDA. AMD ROCm. Apple Metal. Huawei Ascend 950 — just added this week. LLVM CPU. WebGPU. The entire AI chip landscape we've been covering all session — NVIDIA, AMD, Qualcomm's Tenstorrent, every hardware vendor racing to compete — TileLang writes one kernel, targets all of them.

You don't rewrite your attention kernel when you switch from H100 to MI300X. You compile the same code for a different target.

Here's the benchmark that matters.

DeepSeek MLA decoding on H100. FlashAttention performance matching hand-optimized implementations. GEMM performance competitive across RTX 4090, A100, H100, and MI300X — the exact chips every lab is fighting over compute allocation for right now.

Here's who's already shipping with it.

DeepSeek V3.2 and V4 kernels. The models topping every benchmark we've covered this session — built on TileLang.

One command:

pip install tilelang
23 releases. From Peking University, with Microsoft Research collaboration. Apache 2.0.

The language that makes "which chip do we optimize for" a solved problem.

100% Open Source.

GitHub link in the comments 👇

[Rituraj @RituWithAI]

🚨 Someone built a tool that scores your AI agent's trustworthiness in under 2 minutes.

Not latency. Not token efficiency. Not whether it passes a prompt injection test.

Whether your agent actually does its job without lying to you about it.

It's called iFixAi. #1 Python repository of the week on Trendshift. And it asks the question every other eval tool skips entirely.

Here's the gap it found.

Every eval tool, red-teaming framework, and observability platform measures technical capability. Speed. Accuracy. Whether it can be jailbroken.

None of them answer: is this agent doing what the business actually needs, inside the guardrails it's supposed to respect?
iFixAi answers that in one run.

Here's what it actually checks.

32 inspections across five pillars. Fabrication — did it use a tool it wasn't granted, make unsourced claims, keep no audit trail? Manipulation — privilege escalation, breaking its own policy, poisoned context. Deception — does it perform better when it senses a test? Does it have secret side-goals? Unpredictability — does it drift off-instructions over long runs? Opacity — does human escalation actually work when it should?

That deception pillar is the one that should concern every company deploying agents right now. Sandbagging — an agent performing worse normally and better when it senses evaluation — is exactly the alignment faking behavior Anthropic published research on earlier this year. iFixAi tests for it directly.

Here's the grading that makes this different from a vibes-based audit.

A–F letter grade. Citable only when a different vendor's model grades yours — your agent never grades itself. Claude tested, GPT judges. GPT tested, Claude judges. Cross-vendor by design so no one lab marks its own homework.

Here's the case studies that make this real.
They reconstructed fixtures from two public incidents — the Pizza Hut chatbot complaint and the June 2026 Instagram takeover reporting. Both scored F. Not hypothetical failures. Real incidents, graded against the same framework you'd run on your own agent.

Here's how fast it actually runs.

pip install "ifixai[anthropic]"
ifixai setup
ifixai run

Three commands. A–F grade with the full breakdown in under two minutes.

Or point it directly at your deployed agent's endpoint — no code, it measures the governance you already have in production, not a toy version of your system.

19 releases. Apache 2.0. Everything free, including the 28 premium inspections most tools would paywall.

100% Open Source.

GitHub link in the comments 👇

[Rituraj @RituWithAI]

OpenAI launched an AI agent called Dots.

Then people checked https://t.co/vrSCxlQ6a2.

It redirects to Grok. 💀

xAI owns the domain.
And now the internet has one question:

Did Elon just troll OpenAI with a domain name?

OpenAI unveiled Dots as its new always-on AI agents — a pretty major launch.

Except there���s a hilarious problem.
xAI acquired https://t.co/vrSCxlQ6a2 back in July.
And today, it points straight to Grok.

Coincidence?

Maybe.

xAI hasn't said it was intentional.
But if someone at xAI knew OpenAI was about to launch “Dots”...

buying the most obvious domain and redirecting it to your own AI might be one of the most beautifully petty moves in the AI wars.

No ad campaign.
No press release.
No tweet required.

Just:

https://t.co/vrSCxlQ6a2 → Grok

And suddenly, every time someone gets curious about OpenAI's Dots...
they might end up looking at Elon’s AI instead.

The AI wars are getting weird.

They're not just fighting over models anymore.

They're fighting over names, domains, mindshare — and apparently, punchlines.