←
Mr. Ånand15,339 posts
Mr. Ånand avatar✓

Mr. Ånand ✓

@Astrodevil_

🥑DevRel | 🧑‍💻Co-Founder ➝ @Studio1HQ 📤Newsletter ➝ @DailyAI_Insight ⚡️Building ➝ @raahdotdev / assetsnip.com

◷ Joined June 2019▧ 2,028 Photos and videos
Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Nov 10

Upload a patient spreadsheet to ChatGPT and every phone number, email and medical record number leaves your device with it. Agent Guard from @Jozu_AI redacts that on your Mac before the request goes out. Understand with a small demo, a fictional appointment sheet goes into the ChatGPT desktop app. ChatGPT still summarized all the appointment reasons, but every email and phone number came back as [redacted by Jozu]. How the setup works: → Policy Gateway sits between the AI client and the model provider → The shipped reference policy already redacts phone numbers → You add a custom GuardrailPolicy YAML with a regex rule for emails → Restart the gateway, then check agentguard logs --gateway to confirm it worked One catch: Excel files get masked in place, but PDFs and images can't be, so a matching rule may deny the request instead. The model keeps the useful context and never sees who the patients are. Full walkthrough here👇 jozu.com/blog/redact-phi-age…

Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Oct 28

Postgres didn't speak SQL for its first 8 years. Here's how a Berkeley research project that got too popular to support turned into PostgreSQL:

Post attachment
Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Nov 10

MIT's free Missing Semester 2026 has a full lecture on coding agents. 10 things the Agentic Coding lecture covers: 1/ How a harness works. Tool results go back into the prompt, so the model runs again on every tool call. The core fits in about 200 lines of code. 2/ Privacy. Most setups send a lot of your code and conversation to the cloud by default. 3/ Tests first. Write the tests, check them yourself, then ask the agent to implement. 4/ Feedback loops. Let the agent run the failing check itself so it can keep iterating. 5/ Parallel agents on git worktrees, so two agents don't step on each other's changes. 6/ MCP, to connect agents to tools like your docs workspace. 7/ Context control: clear it for unrelated tasks, rewind instead of piling on corrections, and know when compaction kicks in. 8/ llms.txt, a denser doc for agents than an HTML page. 9/ AGENTS. md or CLAUDE. md loads in full every session. Skills add a layer so the agent only opens what it needs. 10/ Subagents, so web research doesn't flood the main agent's context. The other 8 lectures cover the shell, Git, debugging and profiling, packaging and code quality. Notes, exercises and YouTube recordings are all free. missing.csail.mit.edu/2026

Post attachment
Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Oct 28

Cursor's Agent SDK turns an agent into a folder: instructions.md is the prompt tools/ has one typed action per file skills/ holds procedures it loads on demand channels/ is where it wakes up: PRs, CI, Slack, webhooks, cron The part I'd use first is evals. An eval sends a fixed message and checks which tools ran, and with what input. When I benchmarked an AI code reviewer, I gave it read-only tools on purpose. With evals, "never touched a write tool" becomes a CI check instead of a hope. Test what your agent must not do.

0:28
Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Nov 10

gputaskman is a terminal task manager that shows what's actually sitting in your GPU memory, including how much an LLM really needs once the KV cache is counted. A 0.6B model at 32k context needs about 3.5 GB of VRAM just for its KV cache. The weights are 604 MB. Task Manager tells you "15 GB used". This tries to tell you by what: model weights, KV cache, compute buffers, your browser, or the desktop compositor. In one example on a 16 GB RTX 4080 SUPER, the compositor holds 2.18 GB, the LLM process 1.31 GB and the browser 977 MB. What it shows: 1. VRAM and GPU activity per process 2. Which runtime and model file each process has loaded, like llama.cpp with a Qwen3 GGUF 3. An LLM's memory split into weights, KV cache and compute buffers, plus the KV cost per token so you can see what a longer context will cost before you set it 4. Spill, how much of each process got pushed out into system RAM 5. A --json mode, so you can log it from a script Windows with NVIDIA or AMD, Linux, WSL and Apple Silicon. No CUDA Toolkit, admin session or API key needed. Free, MIT. github.com/shanselman/gputas…

Post attachment
Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Oct 28

Read the pricing page. GPT-6.1 Terra, per 1M tokens: $1 input, $0.05 cached input, $5 output GPT-5.6 Terra was $2 input, $12 output The fine print: Over 272K input tokens, the whole request is billed at 2x input and 1.5x output 1.05M context, 128K max output No audio or video input, no fine-tuning Terminal-Bench 4.0 at max effort: 50.3%, up from 21.5%. OpenAI still says Sol and Astra are the better pick for the hardest coding tasks. Cheaper per token. Check what it costs per task on your own workload.

0:31
Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Nov 10

Exact lets a coding agent build an app, run it, see it and test it on web, macOS, iOS and Linux, with no person in the loop. It's the new framework from Expo co-founder Charlie Cheever, written in Rust. The UI is written in Contract, a small declarative language, and the data logic in TypeScript or Rust. It runs natively, with no webview and no JavaScript bridge in the UI, and on the web a ~20 KB runtime drives the real DOM. It's built on the assumption that much of the code will be written by AI agents. → Ten operations, the same on every host: tree, screenshot, tap, type, state, layout, logs, clock, prefer, perf, all through one script → The agent owns the clock, so it moves time with clock +60000 or clock settle instead of waiting on animations → Tests are scripts of those same operations and run unchanged on any host → contract build --json returns diagnostics with stable ids and source ranges → The driver refuses to run a build older than its sources and names the rebuild → Mistakes come back as refusals that say what to do → A whole app fits in a context window github.com/expo/exact

0:35
Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Nov 16

𝗣𝗿𝗼𝗱𝘂𝗰𝘁 𝗛𝘂𝗻𝘁 𝗶𝘀𝗻'𝘁 𝘁𝗵𝗲 𝗼𝗻𝗹𝘆 𝗽𝗹𝗮𝗰𝗲 𝘁𝗼 𝗹𝗮𝘂𝗻𝗰𝗵 𝗮 𝗱𝗲𝘃𝘁𝗼𝗼𝗹 Worth saving before your next launch: → Product Hunt Free to launch. New accounts need posting access first → Peerlist Launchpad Weekly launches with public voting → DevHunt Only dev tools. Listing is free, a launch week costs $49 → Show HN For something people can try right away, no signup wall → Uneed Free if you join the line. Pay to pick your own date → Microlaunch Built around 30 days of exposure after you launch → Fazier Daily launches with a leaderboard → BetaList Early adopters browsing new startups. Paid, pre-launch is fine → AlternativeTo List it next to the tools it replaces. Free, reviewed before it goes live

Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·20h

you can now change T3 Code itself by asking its own agent, and the UI updates while you're using it it's nightly-only so far. a non-dev on stable asked their agent for it anyway, and the agent cloned the source. they're running a fork now

0:13
Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Nov 16

> agent opens a PR > review agent leaves a handful of nits > first agent fixes every one > another agent merges it

Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Oct 27

The Genie 4 demo is what everyone will share. For devs, the more interesting bit is further down the announcement: Gemini API and AI Studio early access, coming soon. What Google says it does: you steer a world in real time (events, camera angles, actions), there's native audio with characters that talk back, and it handles physics, with multi-step events planned through Gemini reasoning. Today it's a research preview for trusted testers. Project Genie on AI Ultra and the API early access are both "coming soon". So beyond those testers, nobody is building on it yet, and the realism and physics claims are Google's. If the API does open up, the use I most want to see is agent testing. Put an agent in a world you can steer, then change something halfway through the task that it wasn't trained for, like a door that's suddenly locked. Static benchmarks never change mid-task, and real environments do all the time. Game prototyping is the obvious other one: describe a level, walk around it and change the rules before anyone opens an engine. What would you build first with a steerable world model?

2:27
Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Oct 27

If you run Claude Code or Codex in a JetBrains terminal, the terminal underneath is about to change. JetBrains 2026.3 swaps its old terminal engine, JediTerm, for libghostty, the library under Ghostty. It's on by default in the 2026.3 EAP. Going by JetBrains' own annual reports, Mitchell counts 12.5M+ active users about to get it. For agent CLIs, Shift+Enter is now a new line in your prompt instead of a half-sent message (that's the Kitty keyboard protocol). Theme-aware TUIs follow the IDE's dark/light theme on their own. Almost 50 control sequences the old engine ignored or misread now render properly. If something breaks, there's a registry switch back to the old engine: terminal.use.ghostty.emulator Ghostty 1.4 came out the same day. Idle scrollback gets compressed, for 70 to 90% less physical memory, and the default scrollback goes from 10 MB to 50 MB. On macOS, throughput is up 25 to 55% after they found the kernel caps pty reads at about 1 KiB. Plain-ASCII parsing goes from 128 to 725 MB/s in parser benchmarks. The scrollback change is the one I care about most. Agents dump a lot of log output into the terminal, and this gives you five times the history at roughly the memory it used to take 🔥

Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Oct 27

Liquid AI and OpenBMB both shipped small models last night, and I keep thinking about using them to check an agent's output. LFM3-1.7B first. The architecture is more interesting to me than the benchmark chart. It has 24 layers: 13 gated short convolutions, 5 sliding-window attention and 6 global attention. My read: the convs and 256-token windows stay fixed-size, so only the 6 global layers keep a cache that grows with context. Liquid says a full 128K context needs 1.6 GB of KV cache, vs 4.3 GB for Qwen3.5-4B. It's about 1 GB at 4-bit, and GGUF, MLX and ONNX were out on day 0. On Liquid's own table it beats Qwen3.5-9B on WebArena-Verified (38.4 vs 28.9) and BFCL V4 (71.4 vs 62.8), but the 9B still wins SWE-bench Verified, 51.2 to 43.4. The model card also says it isn't meant for agentic coding or complex multi-step reasoning, so I wouldn't put it in a coding loop. The same family has d1, decision models that return typed outputs with calibrated probabilities. Liquid says you can fine-tune them on one GPU. OpenBMB released Jev the same night, a 2B model that checks OCR output, tested on four different parsers. They report 93.6 on their own JevOCRBench, vs 93.8 for Qwen3.5-397B. All these numbers are self-reported. Still, a 2B model that scores your agent's output before it writes or sends anything looks like a cheap thing to try. One thing to check before you ship LFM3: the license only covers free commercial use under $10M annual revenue. Would you put a 2B checker in front of your agent? 👀

1:02
Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Nov 16

𝗹𝗹𝗮𝗺𝗮.𝗰𝗽𝗽 𝟭.𝟬 𝗰𝗼𝗺𝗲𝘀 𝘄𝗶𝘁𝗵 𝗮 𝗽𝗿𝗼𝗺𝗶𝘀𝗲: 𝗲𝘃𝗲𝗿𝘆 𝗽𝗹𝗮𝘁𝗳𝗼𝗿𝗺, 𝗲𝘃𝗲𝗿𝘆 𝗺𝗼𝗱𝗲𝗹 The ggml team's post says it already supports more than 150 architecture variants, and each hardware backend can be built as its own library and loaded at runtime. They keep adding self-hosted CI runners, with hardware support from NVIDIA, AMD, Qualcomm, Arm, IBM and Intel. A lot of local AI apps already depend on it.

0:33
Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Oct 27

“AI does not have an intelligence problem. It has a context problem.” That's Databricks CEO Ali Ghodsi, quoted in the Databricks profile Ben Horowitz co-wrote for a16z. I agree with him, and it's the part of the agent conversation that keeps getting skipped. When an agent gets real work wrong, it's usually not because the model is too dumb. It doesn't know which record is current, who owns the decision, or what changed yesterday. Ghodsi's argument is that before companies trust agents to change real records, agents need a new system of record, somewhere the context lives and stays accurate. Coding agents show the same thing on a smaller scale. What they do depends as much on the context files you give them (AGENTS.md, CLAUDE.md, the docs) as on which model you picked. If those files are out of date, the agent will follow them anyway. The piece says work may move from "everyone is an engineer" to "everyone is a manager". If agents do more of the doing, a lot of the human job becomes checking their work and keeping that context up to date. The growth numbers in the piece come from Databricks and a16z, and a16z is an investor. Where does your agent's context actually live today?

Mr. Ånand avatar
⟳ Mr. Ånand retweeted
Mr. Ånand@Astrodevil_·Nov 9

𝗖𝗹𝗮𝘂𝗱𝗲 𝗙𝗮𝗯𝗹𝗲 𝟱.𝟮 𝗶𝘀 𝗰𝗵𝗲𝗮𝗽𝗲𝗿 𝘁𝗵𝗮𝗻 𝟱.𝟭, 𝗮 𝗹𝗼𝘁 𝗯𝗲𝘁𝘁𝗲𝗿 𝗮𝘁 𝗹𝗼𝗻𝗴 𝗰𝗼𝗱𝗶𝗻𝗴 𝘄𝗼𝗿𝗸, 𝗮𝗻𝗱 𝘁𝗵𝗿𝗲𝗲 𝗿𝗲𝗾𝘂𝗲𝘀𝘁𝘀 𝗿𝗲𝘁𝘂𝗿𝗻 𝗮 𝟰𝟬𝟬. Price drops to $8 / $40 per million tokens, from $10 / $50. Still 1M context and 128K max output. On Anthropic's own evals, FrontierCode 2.0 goes from 32.4% to 49.1%. At high effort it roughly matches Opus 5.5's best score for about half the cost per task. The bigger jump is robotics. On RoboDojo, where the model drives a simulated two-arm robot from camera images, it scores 64.9%. Fable 5.1 got 27.6% and Opus 5.5 got 39.4%. That's the clip. It isn't ahead everywhere. Gemini 4 Carbon still beats it on AutomationBench, 53.9% to 51.4%. Before you switch to claude-fable-5-2, these return a 400: 1. Sending a thinking block back after you edited the system prompt, tools or an earlier message. That check runs on every account now. 2. Setting thinking to enabled or disabled. Thinking is always adaptive, and you pick depth with effort, from low to max. High is the default. 3. The old computer_20251124 tool. Computer use needs computer_toolset_20260801, except on Bedrock. If you need speed, speed: "fast" on the request gives up to 2.5x more output tokens per second, at $16 / $80. The long-run demo is the Fermat one. 1,000 Fable 5.2 agents formalized Fermat's Last Theorem in Lean in 30 hours. With the same setup, Opus 5.5 got to 26% in 18 hours and barely moved after 30.

0:23