Show HN: AI Subroutines – Run automation scripts inside your browser tab https://ift.tt/jJLSZRb

Show HN: AI Subroutines – Run automation scripts inside your browser tab We built AI Subroutines in rtrvr.ai. Record a browser task once, save it as a callable tool, replay it at: zero token cost, zero LLM inference delay, and zero mistakes. The subroutine itself is a deterministic script composed of discovered network calls hitting the site's backend as well as page interactions like click/type/find. The key architectural decision: the script executes inside the webpage itself, not through a proxy, not in a headless worker, not out of process. The script dispatches requests from the tab's execution context, so auth, CSRF, TLS session, and signed headers get added to all requests and propagate for free. No certificate installation, no TLS fingerprint modification, no separate auth stack to maintain. During recording, the extension intercepts network requests (MAIN-world fetch/XHR patch + webRequest fallback). We score and trim ~300 requests down to ~5 based on method, timing relative to DOM events, and origin. Volatile GraphQL operation IDs are detected and force a DOM-only fallback before they break silently on the next run. The generated code combines network calls with DOM actions (click, type, find) in the same function via an rtrvr.* helper namespace. Point the agent at a spreadsheet of 500 rows and with just one LLM call parameters are assigned and 500 Subroutines kicked off. Key use cases: - record sending IG DM, then have reusable and callable routine to send DMs at zero token cost - create routine getting latest products in site catalog, call it to get thousands of products via direct graphql queries - setup routine to file EHR form based on parameters to the tool, AI infers parameters from current page context and calls tool - reuse routine daily to sync outbound messages on LinkedIn/Slack/Gmail to a CRM using a MCP server We see the fundamental reason that browser agents haven't taken off is that for repetitive tasks going through the inference loop is unnecessary. Better to just record once, and get the LLM to generate a script leveraging all the possible ways to interact with a site and the wider web like directly calling backed API's, interacting with the DOM, and calling 3P tools/APIs/MCP servers. https://ift.tt/J5mrUDp April 18, 2026 at 04:03AM

Show HN: Praxis – Lab data to publication-ready figures in one Python package https://ift.tt/itwyvOA

Show HN: Praxis – Lab data to publication-ready figures in one Python package https://ift.tt/u5Nj9xO April 19, 2026 at 01:15AM

Show HN: I built Panda to get up to 99% token savings https://ift.tt/NL73vPK

Show HN: I built Panda to get up to 99% token savings https://ift.tt/dVw9mNM April 18, 2026 at 05:00PM

Show HN: Waputer – The WebAssembly Computer https://ift.tt/nlCwDAr

Show HN: Waputer – The WebAssembly Computer Waputer is an operating system that runs entirely in the browser. When you visit the website at https://waputer.app , a kernel written in JavaScript sets up a filesystem and launches a WebAssembly program, which in turn talks to the kernel to handle the display and input. A purely terminal-based version is at https://waputer.dev . My original intention was to create programs that run in the browser that have a lot more in common with the desktop. The traditional "hello world" program is not really suited for the web. Waputer changes that. The GitHub repo at https://ift.tt/g5z06Up gives a very brief overview of compiling a C program and running it on Waputer. There is a blog available from the main site that has a long-form explanation of Waputer and my motivations if you want some additional reading. https://waputer.app April 18, 2026 at 12:46AM

Show HN: Smol machines – subsecond coldstart, portable virtual machines https://ift.tt/ZBLptF2

Show HN: Smol machines – subsecond coldstart, portable virtual machines https://ift.tt/Ur5cJgS April 18, 2026 at 12:18AM

Show HN: Bird, a CLI for Tired Brains https://ift.tt/3XBzHEO

Show HN: Bird, a CLI for Tired Brains https://ift.tt/hSZ4xpo April 18, 2026 at 12:13AM

Show HN: PanicLock – Close your MacBook lid disable TouchID –> password unlock https://ift.tt/QFPhEV5

Show HN: PanicLock – Close your MacBook lid disable TouchID –> password unlock https://ift.tt/ivusXmS April 17, 2026 at 11:38PM

Show HN: EDDI – Multi-agent AI engine where agent logic lives in JSON, not code https://ift.tt/FLnKJU5

Show HN: EDDI – Multi-agent AI engine where agent logic lives in JSON, not code I started EDDI in 2006 as a rule-based dialog engine. Back then it was pattern matching and state machines. When LLMs showed up, the interesting question wasn't "how do I call GPT" but "how do I keep control over what the AI does in production?" My answer was: agent logic belongs in JSON configs, not code. You describe what an agent should do, which LLM to use, what tools it can call, how it should behave. The engine reads that config and runs it. No dynamic code execution, ever. The LLM cannot run arbitrary code by design. The engine is strict so the AI can be creative. v6 is the version where this actually became practical. You can have groups of agents debating a topic in five different orchestration styles (round table, peer review, devil's advocate...). Each agent can use a different model. A cascading system tries cheap models first and only escalates to expensive ones when confidence is low. It also implements MCP as both server and client, so you can control EDDI from Claude Desktop or Cursor. And Google's A2A protocol for agents discovering each other across platforms. The whole thing runs in Java 25 on Quarkus, ships as a single Docker image, and installs with one command. Open source since 2017, Apache 2.0. Would love to hear thoughts on the architecture and feature set. And if you have ideas for what's missing or what you'd want from a system like this, I'm all ears. Always looking for good input on the roadmap. https://ift.tt/Rp83Xwo April 16, 2026 at 09:11PM

Show HN: CodeBurn – Analyze Claude Code token usage by task https://ift.tt/4pnvwDZ

Show HN: CodeBurn – Analyze Claude Code token usage by task Built this after realizing I was spending ~$1400/week on Claude Code with almost no visibility into what was actually consuming tokens. Tools like ccusage give a cost breakdown per model and per day, but I wanted to understand usage at the task level. CodeBurn reads the JSONL session transcripts that Claude Code stores locally (~/.claude/projects/) and classifies each turn into 13 categories based on tool usage patterns (no LLM calls involved). One surprising result: about 56% of my spend was on conversation turns with no tool usage. Actual coding (edits/writes) was only ~21%. The interface is an interactive terminal UI built with Ink (React for terminals), with gradient bar charts, responsive panels, and keyboard navigation. There’s also a SwiftBar menu bar integration for macOS. Happy to hear feedback or ideas. https://ift.tt/dbt8nS1 April 14, 2026 at 05:57AM

Show HN: Dependicus, a dashboard for your monorepo's dependencies https://ift.tt/AOLem6p

Show HN: Dependicus, a dashboard for your monorepo's dependencies Late last year, I was digging into some dependency-related tech debt, and struggling with how long it takes to run pnpm's introspection commands like 'pnpm why' in a medium-size monorepo. So I started working on a simple static site generator that would let me view the output of these expensive commands all at once, to make problems clearly visible instead of requiring deep exploration one at a time. Once I had that working, I realized I had enough data to add ticket tracking. It uses the data it gathers from the package manager to keep Linear or GitHub issues updated. And by auto-assigning those issues to coding agents, I get a Dependabot-but-better experience: agents keep up with API updates in addition to just bumping versions, and group related updates automatically. It's still early days, but it's working really well for us and I think people will find value in it, so I'm sharing here! https://descriptinc.github.io/dependicus/ April 16, 2026 at 12:02AM

Show HN: MCP server gives your agent a budget (save tokens, get smarter results) https://ift.tt/zD7ofRZ

Show HN: MCP server gives your agent a budget (save tokens, get smarter results) As a consultant I foot my own Cursor bills, and last month was $1,263. Opus is too good not to use, but there's no way to cap spending per session. After blowing through my Ultra limit, I realized how token-hungry Cursor + Opus really is. It spins up sub-agents, balloons the context window, and suddenly, a task I expected to cost $2 comes back at $8. My bill kept going up, but was I really going to switch to a worse model? No. So I built l6e: an MCP server that gives your agent the ability to budget. It works with Cursor, Claude Code, Windsurf, Openclaw, and every MCP-compatible application. Saving money was why I built it, but what surprised me was that the process of budgeting changed the agent's behavior. An agent that understands the limitations of the resources doesn't try to speculatively increase the context window with extra files. It doesn't try to reach every possible API. The agent plans ahead, sticks to it, and ends work when it should. It works, and we've been dogfooding it hard. After v1 shipped, the rest of l6e was all built with it. We launched the entire docs site using frontier models for $0.99. The kicker was every time l6e broke in development, I could feel the pain. The agent got sloppy, burned through context, and output quality dropped right along with it. Install: pip install l6e-mcp Docs: https://docs.l6e.ai GitHub: https://ift.tt/Ze3Aaxg Website: https://l6e.ai Happy to answer questions about the system design, calibration models, or why I can't go back to coding without it. https://l6e.ai April 15, 2026 at 10:38PM

Show HN: A Claude Code–driven tutor for learning algorithms in Go https://ift.tt/wTClJbg

Show HN: A Claude Code–driven tutor for learning algorithms in Go https://ift.tt/9o8brjG April 15, 2026 at 12:41AM

Show HN: LangAlpha – what if Claude Code was built for Wall Street? https://ift.tt/nqNr1Zw

Show HN: LangAlpha – what if Claude Code was built for Wall Street? Some technical context on what we ran into building this. MCP tools don't really work for financial data at scale. One tool call for five years of daily prices dumps tens of thousands of tokens into the context window. And data vendors pack dozens of tools into a single MCP server, schemas alone can eat 50k+ tokens before the agent does anything useful. So we auto-generate typed Python modules from the MCP schemas at workspace init and upload them into the sandbox. The agent just imports them like a normal library. Only a one-line summary per server stays in the prompt. We have around 80 tools across our servers and the prompt cost is the same whether a server has 3 tools or 30. This part isn't finance-specific, it works with any MCP server. The other big thing was making research actually persist across sessions. Most agents treat a single deliverable (a PDF, a spreadsheet) as the end goal. In investing that's day one. You update the model when earnings drop, re-run comps when a competitor reports, keep layering new analysis on old. But try doing that across agent sessions, files don't carry over, you re-paste context every time. So we built everything around workspaces. Each one maps to a persistent sandbox, one per research goal. The agent maintains its own memory file with findings and a file index that gets re-read before every LLM call. Come back a week later, start a new thread, it picks up where it left off. We also wanted the agent to have real domain context the way Claude Code has codebase context. Portfolio, watchlist, risk tolerance, financial data sources, all injected into every call. Existing AI investing platforms have some of that but nothing close to what a proper agent harness can do. We wanted both and couldn't find it, so we built it and open-sourced the whole thing. https://ift.tt/gE3LiU7 April 14, 2026 at 09:48PM