Show stories

Hi HN!

I built NaturalCron because I was tired of writing and debugging CRON syntax like:

/5 * * 5

Now you can write something human-readable in .NET:

var expression = new NaturalCronExpression("every 5 minutes on friday");

Or use a Fluent Builder for strong typing and IDE support:

var expression = NaturalCronExpressionBuilder .Every().Minutes(5) .On(DayOfWeek.Friday) .Build();

Great for: - Code-based scheduling in .NET apps - Overriding schedules from configs or databases - Displaying easy-to-read rules in UIs

NuGet: https://www.nuget.org/packages/NaturalCron GitHub: https://github.com/hugoj0s3/NaturalCron

Would love your feedback on syntax, builder design, and what features you'd like to see next!

Browser LLM demo working on JavaScript and WebGPU. WebGPU is already supported in Chrome, Safari, Firefox, iOS (v26) and Android.

Demo, similar to ChatGPT https://andreinwald.github.io/browser-llm/

Code https://github.com/andreinwald/browser-llm

- No need to use your OPENAI_API_KEY - its local model that runs on your device

- No network requests to any API

- No need to install any program

- No need to download files on your device (model is cached in browser)

- Site will ask before downloading large files (llm model) to browser cache

- Hosted on Github Pages from this repo - secure, because you see what you are running

This is software for my headless, PC based oscilloscope, which is controlled entirely via commands similar to the Vim text editor. I built this because I liked the idea of headless oscilloscopes; I always have my laptop around when I’m working on electronics anyway, and it’s very convenient to save images of captured waveforms. However, I found the software for off the shelf models to be annoying and cumbersome to work with. In my experience, this holds true both when opening the software and connecting to an attached oscilloscope, and when adjusting the scope settings using menus and buttons. I have also built my own oscilloscope hardware for use with Voltpeek. The specs are nothing to write home about (7.5MHz BW, 62.5MS/s), but they should be adequate for some basic debugging and measurement tasks.

Some months ago @andrewrn tried to create a Wordle-style site for order-of-magnitude thinking. This was a wonderful idea, but the actual site was somewhat over-engineered and confusing. (https://news.ycombinator.com/item?id=43632278)

In the past week, I looked at this idea again and built a very simple site which gives you a new Fermi estimation question every day:

How many new cars were sold in the US in 2024?; How many humans have ever lived (including those currently alive)?; How many chickens are slaughtered for meat every year?

To win, you need a guess within ±20% of the correct answer. For this you have a maximum of 6 tries and after each guess, you can see if your answer was too high or too low.

Fermi questions are, by the way, a wonderful way to build up your own numeracy and sense for order-of-magnitude differences. Douglas Hofstadter proposed using them for exactly this reason in his essay "Number Numbness, or Why Innumeracy May Be Just as Dangerous as Illiteracy" (https://gwern.net/doc/math/1982-hofstadter-2.pdf)

Hi HN. I built a prototype AI physics tutor that can interpret, draw, and edit free body diagrams.

Lately I've been transfixed with generating diagrams with LLMs. If you pipe generated JSON through a D3.js renderer, you can get pretty consistent SVG results with the smarter models.

This physics tutor prototype is an example of an application. For a couple premade scenes, you can ask it to make an FBD, decompose an angled force into components, run through the math of Newton's Second Law, or off-road and try and generate a FBD for a scene of your own description.

I previously made a similar example for electrical circuits: www.circuit-tutor.xyz

LLMs have been really fun for me to brush up on my favorite physics and engineering topics, but if they could diagram and even simulate systems while also being able to explain the math, I think it could be genuinely useful for learning concepts from scratch.

Would love any feedback on whether this, bolstered with more diagram types, better UX, and more robustness, could be useful for people learning intro physics.

Made this website as an exercise in vibe-coding and GCP. It was posted about a few times around the internet, on sites like [Morning Brew](https://www.morningbrew.com/issues/business-buzzkill), [MetaFilter](https://www.metafilter.com/209703/Draw-A-Fish), boingboing.net, etc. I think it's cute!

I built a basic CNN trained against penises and swastikas, and then anything that doesn't hit the 63% confidence score gets sent to a mod queue, a [vibe-coded fish-tinder](https://bsky.app/profile/bigass.bsky.social/post/3luvikxn3f2...).

Was a fun exercise, spent about a month on it. Frontend is HTML5 hosted on github pages, backend is Node.JS on GCP.

There are plenty of HTTP clients out there - Axios being one of the most popular - but I wanted something minimal and closer to the native fetch API.

I originally wrote a small fetch wrapper for a side project. Rather than copying and pasting it into other projects, I decided to expand on it and publish it as a public package.

Feel free to star the repo, and more importantly, contribute.

I recently wrote and launched a high-performance Elevation API, built from the ground up, in C. I was highly inspired by the handmade community and I was intrigued by the idea of handling fairly large datasets and optimizing caching and smart prefetching, and to cream out maximum performance in terms of latency and handling large loads.

The whole thing is built from scratch. I wanted to roll my own high performance server that could handle a lot, mostly for the technical challenge but also because it brings down hosting costs.

At the core is a hand made TCP server where a single thread handles all I/O via epoll, distributing the events to a pool of worker threads. The server is fully non-blocking and edge-triggered, with a minimal syscall footprint during steady-state operation.

Worker threads handle request parsing and perform either direct elevation lookups for single- or multi-points, or compute sample points along polyline paths.

The elevation data is stored as memory mapped geotiff raster tiles, The tiles are indexed in an R-tree for fast lookup. Given a coordinate, the correct tile is located with a bounding-box search algorithm through the tree, and the elevation value is extracted directly from the mapped memory. If the tile is missing the data, underlying tiles act as fallback.

I also implemented a prefetching mechanism. That is, to avoid repeated page faults in popular areas, I employ a strategy where each tile is divided into smaller sub-tiles. Then, I have a running popularity count per sub-tile. This information is then used to guide prefetching. More popular sub-tiles trigger larger-radius prefetches around the lookup point, with the logic that if a specific region is seeing frequent access, it’s worth pulling in more of it into RAM. Over time, this makes the memory layout adapt to real usage patterns, keeping hot areas resident and minimizing I/O latency. Prefetching is done using linux madvise, in a separate prefetch thread to not affect request latency.

There’s a free option to try it out!

Hypersigil is an open-source platform that enables the creation and distribution of digital art NFTs. It provides tools for artists to mint, sell, and manage their NFT collections, as well as a marketplace for buyers to discover and purchase NFTs.

Hey Xinwei and Zecheng here, we are the authors of TraceRoot (https://github.com/traceroot-ai/traceroot).

TraceRoot (https://traceroot.ai) is an open-source debugging platform that helps engineers fix production issues faster by combining structured traces, logs, source code contexts and discussions in Github PRs, issues and Slack channels, etc. with AI Agents.

At the heart are our lightweight Python (https://github.com/traceroot-ai/traceroot-sdk) and TypeScript (https://github.com/traceroot-ai/traceroot-sdk-ts) SDKs - they can hook into your app using OpenTelemetry and captures logs and traces. These are either sent to a local Jaeger (https://www.jaegertracing.io/) + SQLite backend or to our cloud backend, where we correlate them into a single view. From there, our custom agent takes over.

The agent builds a heterogeneous execution tree that merges spans, logs, and GitHub context into one internal structure. This allows it to model the control and data flow of a request across services. It then uses LLMs to reason over this tree - pruning irrelevant branches, surfacing anomalous spans, and identifying likely root causes. You can ask questions like “what caused this timeout?” or “summarize the errors in these 3 spans”, and it can trace the failure back to a specific commit, summarize the chain of events, or even propose a fix via a draft PR.

We also built a debugging UI that ties everything together - you explore traces visually, pick spans of interest, and get AI-assisted insights with full context: logs, timings, metadata, and surrounding code. Unlike most tools, TraceRoot stores long-term debugging history and builds structured context for each company - something we haven’t seen many others do in this space.

What’s live today:

- Python and TypeScript SDKs for structured logs and traces.

- AI summaries, GitHub issue generation, and PR creation.

- Debugging UI that ties everything together

TraceRoot is MIT licensed and easy to self-host (via Docker). We support both local mode (Jaeger + SQLite) and cloud mode. Inspired by OSS projects like PostHog and Supabase - core is free, enterprise features like agent mode multi-tenant and slack integration are paid.

If you find it interesting, you can see a demo video here: https://www.youtube.com/watch?v=nb-D3LM0sJM

We’d love you to try TraceRoot (https://traceroot.ai) and share any feedback. If you're interested, our code is available here: https://github.com/traceroot-ai/traceroot. If we don’t have something, let us know and we’d be happy to build it for you. We look forward to your comments!

historically, rentals in NYC have been pretty wild. the median 1BR in West Village as of July 2025 cost $5,750/month. about a month ago, NYC passed a law to ban broker fees which many predicted would have increased rents. I realized I had access to some original data from a previous project so I built a dashboard to help me visualize the changes and see for myself.

you can filter by neighborhoods, bedrooms, original source where the rentals were posted, and select a timeframe.

this is still a work in progress, so apologies in advance for any issues you encounter. I would love any feedback on how to improve it and/or what other visualizations i should add. known issues include:

- some neighborhoods like Prospect Park will also automatically select other, unrelated, neighborhoods when selected

- sometimes even when you filter by 1BR it will also include some 2BR

- some units might have been listed on multiple platforms, effectively counting as duplicates

Hey Pietro and Luigi here, we are the authors of mcp-use (https://github.com/mcp-use/mcp-use).

When the first MCP servers came out we were very excited about the technology, but as soon as we wanted to get our hands dirty, we found out that MCP could be used only through Claude Desktop or Cursor. As engineers, we did not like that. MCP seemed like something you wanted to use to build products and applications yourself, not something to hide behind a closed source application.

So we approached the SDK but were pretty dissatisfied with the developer experience (double async loops, lots of boilerplate). We decided to write mcp-use to make our lives easier.

mcp-use lets you connect any LLM to any MCP server in just 6 lines of code. We provide a high level abstraction over the official MCP SDK that makes your life easier and supports all the functionalities of the protocol.

Demo video here: https://www.youtube.com/watch?v=nL_B6LZAsp4.

The key abstractions we provide are called MCPClient and MCPAgent.

MCPClient takes in a set of server configurations, automatically detects the transport type and creates a background task which handles the stream from/to the server.

MCPAgent is a combination of the MCPClient, an LLM, and a custom system prompt. It consumes the MCP client by transforming the tools, resources and prompts into model agnostic tools that can be called by the LLM.

The library also contains some cool utilities:

- secure sandboxed execution of MCP servers (we know the protocol doesn't shine for security)

- meta-tools that allow the agent to search over available servers and tools (to avoid context flooding) and connect dynamically to the server it needs (you could create the omnipotent agent with this).

Some cool things we did with this: - write an agent that can use a browser and create/read linear tickets updated with latest information on the internet

- write an agent that has access to the metrics of our company to automatically create weekly reports.

- I connected an agent to an IKEA curtain I hacked an MCP on to adapt the lighting of my room from images of the lighting situation.

- recreated am open source claude code like CLI, with full MCP capability but with custom models and BYOK (https://github.com/mcp-use/mcp-use-cli).

We recently crossed 100,000 download and we are used by many organizations, including NASA!

We’d love to hear what you think of it, most importantly how we can improve it! We are happy to answer any questions and look forward to your comments.

Hey HN, we're Haakam, Michael, and Adi. We're building AgentMail (https://agentmail.to/), an API to give AI agents their own email inboxes. We’re not talking about AI for your email, this is email for your AI.

We started building email agents because they can converse with users in their inboxes, automate email-based workflows, and authenticate with third-party applications. Given these unique capabilities, we think email will be a core interface for agents.

But we were building on top of Gmail, which was a struggle: poor API support, expensive subscriptions, rate limits, sending limits, GCP Pub/Sub, OAuth, crappy keyword search, and an overall terrible developer experience.

Gmail and other providers didn’t work for us. So we decided to bite the bullet and build our own.

AgentMail is like Gmail, but API-first, with programmatic inbox creation, events over webhooks and websockets, simple API key auth, organization-wide semantic search, structured data extraction, and usage-based pricing that scales with emails sent/received.

Here’s a demo of building an email agent: https://youtu.be/1V7BISeFUTM, and here’s a demo of a voice agent with its own email inbox: https://youtu.be/eG2fCsRK4RY

So far AgentMail has been deployed to use cases such as apps with dedicated inboxes for each user, voice agents that receive documents in real time, automated account provisioning and QA testing, cold outbound platforms with thousands of inboxes, automations for processing invoices, and agents that coordinate work with humans and other agents.

We would love to hear your thoughts and feedback. You can try our playground at https://chat.agentmail.to

I wrote this simple Python script that prints the daily weather forecast on those cheap thermal receipt printers you can get online for under fifty bucks. It fetches weather data, converts the icons to something printable, and outputs everything in ESC/POS format so you can pipe it directly to /dev/USB/lp0.

Nothing fancy, i just thought it would be nice to have a physical weather printout each morning.

You can configure it with your GPS coordinates and timezone, and stick it in a cron job.

Enjoy!

Hi HN,

We’re Alex and Kalan, the creators of Pontoon (https://github.com/pontoon-data/Pontoon). Pontoon is an open-source data export platform that makes it really easy to create data syncs and send data to your enterprise customers. Check out our demo here: https://app.storylane.io/share/onova7c23ai6 or try it out with docker: https://pontoon-data.github.io/Pontoon/getting-started/quick...

While at our prior roles as data engineers, we’ve both felt the pain of data APIs. We either had to spend weeks building out data pipelines in house or spend a lot on ETL tools like Fivetran (https://www.fivetran.com/). However, there were a few companies that offered data syncs that would sync directly to our data warehouse (eg. Redshift, Snowflake, etc.), and when that was an option, we always chose it. This led us to wonder “Why don’t more companies offer data syncs?”. It turns out, building reliable cross-cloud data syncs is difficult. That’s why we built Pontoon.

We designed Pontoon to be:

- Easily deployed: we provide a single, self-contained Docker image for easy deployment and Docker Compose for larger workloads (https://pontoon-data.github.io/Pontoon/getting-started/quick...)

- Support modern data warehouses: we support syncing to/from Snowflake, BigQuery, Redshift, and Postgres.

- Sync cross cloud: sync from BigQuery to Redshift, Snowflake to BigQuery, Postgres to Redshift, etc.

- Developer friendly: data syncs can also be built via the API

- Open source: Pontoon is free to use by anyone

Under the hood, we use Apache Arrow (https://arrow.apache.org/) to move data between sources and destinations. Arrow is very performant - we wanted to use a library that could handle the scale of moving millions of records per minute.

In the shorter-term, there are several improvements we want to make, like:

- Adding support for DBT models to make adding data models easier

- UX improvements like better error messaging and monitoring of data syncs

- More sources and destinations (S3, GCS, Databricks, etc.)

- Improve the API for a more developer friendly experience (it’s currently tied pretty closely to the front end)

In the longer-term, we want to make data sharing as easy as possible. As data engineers, we sometimes felt like second class citizens with how we were told to get the data we needed - “just loop through this api 1000 times”, “you probably won’t get rate limited” (we did), “we can schedule an email to send you a csv every day”. We want to change how modern data sharing is done and make it simple for everyone.

Give it a try https://github.com/pontoon-data/Pontoon. Cheers!

Hey everyone! I'm a huge F1 fan and got tired of juggling multiple tabs and apps during race weekends, so I built F1 COSMOS.

What it does:

- Live timing: Real-time data updates in milliseconds - sector times, telemetry, team radio, you name it. No more refreshing pages or waiting for delayed updates.

- Replay feature: Missed qualifying or fell asleep during practice? You can replay the live timing from any past session. Pretty handy when you're in a bad timezone.

- Proper data visualization: I went beyond just showing lap times. There's race analysis with telemetry data, championship standings, technical updates, and a bunch of other stats that make watching races way more interesting. Oh, and the race calendar automatically adjusts to your timezone because I was sick of doing timezone math in my head.

- Multi-device setup: Here's the thing - I watch races on my TV but wanted data on my phone as a second screen. So I spent ages making the mobile experience smooth for exactly this use case. Desktop has customizable widgets if you're into that.

Technical stuff:

Built with modern web stack, focused heavily on real-time performance. The trickiest part was getting the data pipeline right for millisecond updates without everything falling apart.

Why I built this: Honestly, existing F1 apps either suck or cost money or both. I wanted something that just works and gives me all the data I actually care about in one place.

Been using it myself all season and figured others might find it useful. Currently supports English, Spanish, Japanese, and Korean (partially) - still working on expanding language support. Would love to hear what you think if you check it out during the next race weekend.

This article describes a project that implements a todo list using the DuckDB database and the OPFS (Origin-Private File System) API, providing a client-side, offline-first, and serverless approach to managing tasks.

The article describes 'rewindtty', an open-source tool that allows users to replay and analyze their terminal sessions, providing a way to debug and troubleshoot issues that occurred in the past.

Hey HN,

I'm Brandon, a solo dev, and I built KubeForge - a visual editor for Kubernetes deployments that helps you build and validate YAML configs.

Origin Story: Over the past couple weeks, I got fed up manually writing Kubernetes YAMLs, especially when working with nested structures like containers, env, and volumeMounts. Even small typos or misaligned fields added lost time to broken deploys.

So I started hacking together a tool to visualize the structure of Kubernetes objects based on the OpenAPI schema. That prototype quickly turned into a full manifest builder.

What KubeForge does:

- Pulls the latest Kubernetes OpenAPI schema (auto-updated daily)

- Generates field-level forms with type safety, required fields, and smart defaults

- Lets you visually build manifests like a flow editor

- Outputs clean, deploy-ready YAML, with multi-object exports

Personally, I wanted a tool that:

- Validates fields as I build, not after deployment

- Surfaces nested fields, tooltips, and types without switching tabs

- Lets me export or share real YAMLs easily

Try it out:

GitHub: https://github.com/kubenote/KubeForge

Live demo: https://demo.kubefor.ge

Website: https://kubefor.ge

It’s free and open source. I’d love feedback, bug reports, or ideas. Contributions welcome too .

Thanks, Brandon

Hi HN,

We’re Brendan and Michael, the creators of Sourcebot (https://www.sourcebot.dev/), a self-hosted code understanding tool for large codebases. We originally launched on HN 9 months ago with code search (https://news.ycombinator.com/item?id=41711032), and we’re excited to share our newest feature: Ask Sourcebot.

Ask Sourcebot is an agentic search tool that lets you ask complex questions about your entire codebase in natural language, and returns a structured response with inline citations back to your code. Some types of questions you might ask:

- “How does authentication work in this codebase? What library is being used? What providers can a user log in with?” (https://demo.sourcebot.dev/~/chat/cmdpjkrbw000bnn7s8of2dm11)

- “When should I use channels vs. mutexes in go? Find real usages of both and include them in your answer” (https://demo.sourcebot.dev/~/chat/cmdpiuqhu000bpg7s9hprio4w)

- “How are shards laid out in memory in the Zoekt code search engine?” (https://demo.sourcebot.dev/~/chat/cmdm9nkck000bod7sqy7c1efb)

- "How do I call C from Rust?" (https://demo.sourcebot.dev/~/chat/cmdpjy06g000pnn7ssf4nk60k)

You can try it yourself here on our demo site (https://demo.sourcebot.dev/~) or checkout our demo video (https://youtu.be/olc2lyUeB-Q).

How is this any different from existing tools like Cursor or Claude code?

- Sourcebot solely focuses on code understanding. We believe that, more than ever, the main bottleneck development teams face is not writing code, it’s acquiring the necessary context to make quality changes that are cohesive within the wider codebase. This is true regardless if the author is a human or an LLM.

- As opposed to being in your IDE or terminal, Sourcebot is a web app. This allows us to play to the strengths of the web: rich UX and ubiquitous access. We put a ton of work into taking the best parts of IDEs (code navigation, file explorer, syntax highlighting) and packaging them with a custom UX (rich Markdown rendering, inline citations, @ mentions) that is easily shareable between team members.

- Sourcebot can maintain an up-to date index of thousands of repos hosted on GitHub, GitLab, Bitbucket, Gerrit, and other hosts. This allows you to ask questions about repositories without checking them out locally. This is especially helpful when ramping up on unfamiliar parts of the codebase or working with systems that are typically spread across multiple repositories, e.g., micro services.

- You can BYOK (Bring Your Own API Key) to any supported reasoning model. We currently support 11 different model providers (like Amazon Bedrock and Google Vertex), and plan to add more.

- Sourcebot is self-hosted, fair source, and free to use.

Under the hood, we expose our existing regular expression search, code navigation, and file reading APIs to a LLM as tool calls. We instruct the LLM via a system prompt to gather the necessary context via these tools to sufficiently answer the users question, and then to provide a concise, structured response. This includes inline citations, which are just structured data that the LLM can embed into it’s response and can then be identified on the client and rendered appropriately. We built this on some amazing libraries like the Vercel AI SDK v5, CodeMirror, react-markdown, and Slate.js, among others.

This architecture is intentionally simple. We decided not to introduce any additional techniques like vector embeddings, multi-agent graphs, etc. since we wanted to push the limits of what we could do with what we had on hand. We plan on revisiting our approach as we get user feedback on what works (and what doesn’t).

We are really excited about pushing the envelope of code understanding. Give it a try: https://github.com/sourcebot-dev/sourcebot. Cheers!

Hi HN,

I'm a solo indie developer and I built Minecrack, a lightweight Minesweeper-style puzzle game for Android.

Classic gameplay Multiple difficulty levels Works offline No login, no ads (just a clean experience)

The goal was to keep it simple, fast, and familiar — something to play quickly without distractions. I’d love feedback from anyone who’s a fan of logic games, UI minimalism, or retro-style mobile games.

Play Store link: https://play.google.com/store/apps/details?id=com.vdm.minecr...

Thanks in advance for checking it out!

Here's something different than your usual fare: A physical keypad that lets you directly type math!

Ever tried typing mathematical equations in your code IDE, email, or on Slack? You might know it can be tricky. Mathpad solves this with dedicated keys for Greek letters, calculus symbols, and more. Press the ∫ key and get ∫, in any application that accepts text. It uses Unicode composition, so it works everywhere: Browsers, chat apps, code editors, Word, you name it. Basically, anywhere you can type text, Mathpad lets you type mathematics.

I built Mathpad after getting frustrated with the friction of typing equations in e.g. Word, and what a pain in the ass it was to find the specific symbols I needed. I assumed that a product like Mathpad already existed, but that was not true and I had to build it myself.

It turned out to be pretty useful! Three years of solo development later, I'm launching on Crowd Supply. One of the trickiest parts of this project was finding someone who could manufacture custom keycaps with mathematical symbols. Shoutout to Loic at 3dkeycap.com for making it possible!

Fully open source (hardware + software): https://github.com/Summa-Cogni/Mathpad Campaign: https://www.crowdsupply.com/summa-cogni/mathpad Project log: https://hackaday.io/project/186205-mathpad-the-math-keypad

Hey HN! My name is Christian, and I’m the co-founder of https://frigade.ai. We’ve built an AI agent that automatically learns how to use any web-based product, and in turn guides users directly in the UI, automatically generates documentation, and even takes actions on a user’s behalf. Think of it as Clippy from the old MS Office. But on steroids. And actually helpful.

You can see the agent and tool-calling SDK in action here: https://www.youtube.com/watch?v=UPe0t3A1Vpg

How is this different from other AI customer support products?

Most AI "copilots" are really just glorified chatbots. They skim your help center and spit out some nonspecific bullet points. Basically some ‘hopes and prayers’ that your users will figure it out. Ultimately, this puts the burden on the user to follow through. And assumes companies are keeping their help center up-to-date with every product change. That means constant screenshots of new product UI or features for accurate instructions.These solutions leverage only a fraction of what’s possible with AI, which can now reason about software interfaces extensively.

With Frigade AI, we guide the user directly in the product and build on-demand tours based on the current user’s state and context. The agents can also take actions immediately on a user’s behalf, e.g. inviting a colleague to a workspace or retrieving billing information (via our tool calling SDK).

This was only made possible recently. The latest frontier models (GPT 4.1, Claude 4, Gemini 2.5, etc.) are able to reason about UIs and workflows in a way that simply didn’t work just 6 months ago. That’s why we’re so excited to bring this technology to the forefront of complex legacy SaaS applications that are not yet AI enabled.

How does it work?

1. Invite agent@frigade.ai to your product. You can send multiple invitations based on distinct roles.

2. Our agent automatically explores and reasons about your application.

3. Attach any existing help center resources or training documentation to supplement the agent’s understanding. Totally optional.

4. Install the agent assistant Javascript snippet (just a few lines).

5. That’s it. Your users can now start asking questions and get on demand product tours and questions answered in real time without any overhead.

This process takes only a few minutes. Once running, you can improve the agent by rating and providing feedback to the responses it provides. If you want to integrate further, you can also hook up your own code to our tool calling SDK to enable the agent to look up customer info, issue refunds, etc. directly. These calls can be made with just a few lines of code by describing the tool and its parameters in natural language and passing a single Javascript promise (e.g. make an API call, call a function in your app, etc.).

Would love to hear what the HN crowd thinks about this approach! Are you building your own AI agent from scratch, or looking to embed one off the shelf?

Lets imagine a scenario where you're coerced whether through threats, torture, or even legal pressure to reveal the password to your secure vault.

In countries like the US, UK, and Australia, refusing to provide passwords to law enforcement can result months in prison in certain cases.

I invented a solution called Veilith ( veilith.com ) addresses this critical vulnerability with perfect deniable encryption. It supports multiple passwords, each unlocking distinct blocks of encrypted data that are indistinguishable from random noise even to experts. And have a lot of different features to protect your intellectual properties.

In high-stakes situations, simply provide a decoy password and plausibly deny the existence of anything more.

Dive deeper by reading the whitepaper, exploring the open-source code, or asking me any questions you may have.

Hey HN,

I made TubeSummary, a browser extension that adds a summary and Q&A button to YouTube videos. It uses your favorite OpenAI-compatible API (OpenAI, Groq, Together, etc) so you can get quick takeaways or ask the AI about the video — right below the player.

Built it because I got tired of scrubbing through endless videos just to figure out what mattered.

It's open source, I have tested on latest Chrome and Firefox.

A quick heads up for Chrome users: since I don't have a paid Google developer account, the extension isn't on the Chrome Web Store, so you'll need to install it manually. Sorry for the extra hassle! There's a step-by-step guide in the repo if you need it.

We're living in this weird asymmetry where companies use AI to talk to us, but we're still manually dialing them. Companies everywhere are adopting AI voice agents lately. Big retail, family dentist clinics, local pharmacy. This year, I've been in a few calls where it's super natural sounding AI, which has been pretty cool to experience. But then it got me thinking - why are we, the consumers, still the ones making calls if they're using robots for theirs?

So I built Piper: basically AI that makes phone calls for you. You tell it what you need (book appointment, check on an order, dispute some charge, whatever), and it handles the entire conversation while you do actual work. Right now it's a web app, Chrome extension is pending approval but soon you'll be able to click any phone number anywhere and just let Piper handle it.

Technical stuff that was harder than expected:

Latency - every millisecond counts in conversation, had to optimize around kv cache, got it down to ~1000ms to first word over PSTN for telephony, which feels pretty natural

Keeping the voice agents on track - built custom context engineering logic that constantly updates the agent's situational awareness, so it knows when it's been transferred, when it's on hold, etc

Done ~50 successful calls with early testers so far. Main failures are when they need complex verification or documents. Also had to take down our IVR navigation temporarily :/, found some edge cases that were causing unnecessary transfers but working on fixing that.

I really think we're heading toward this world where AI talks to AI for most routine things, and phone calls might be the first real example of this happening at scale!

you can check out the a voice demo on our website. https://pipervoice.com

Hey HN,

We are Winston, Edward, and James, and we built Meka Agent, an open-source framework that lets vision-based LLMs execute tasks directly on a computer, just like a person would.

Backstory:

In the last few months, we've been building computer-use agents that have been used by various teams for QA testing, but realized that the underlying browsing frameworks aren't quite good enough yet.

As such, we've been working on a browsing agent.

We achieved 72.7% on WebArena compared to the previous state of the art set by OpenAI's new ChatGPT agent at 65.4%. You can read more about it here: https://github.com/trymeka/webarena_evals.

Today, we are open sourcing Meka, our state of the art agent, to allow anyone to build their own powerful, vision-based agents from scratch. We provide the groundwork for the hard parts, so you don't have to:

* True vision-based control: Meka doesn't just read HTML. It looks at the screen, identifies interactive elements, and decides where to click, type, and scroll.

* Full computer access: It's not sandboxed in a browser. Meka operates with OS-level controls, allowing it to handle system dialogues, file uploads, and other interactions that browser-only automation tools can't.

* Extensible by design: We've made it easy to plug in your own LLMs and computer providers.

* State-of-the-art performance: 72.7% on WebArena

Our goal is to enable developers to create repeatable, robust tasks on any computer just by prompting an agent, without worrying about the implementation details.

We’d love to get your feedback on how this tool could fit into your automation workflows. Try it out and let us know what you think.

You can find the repo on GitHub and get started quickly with our hosted platform, https://app.withmeka.com/.

Thanks, Winston, Edward, and James

We’ve published a set of open-source reference implementations on how to build production-grade Agentic AI applications on AWS.

What’s in the repo: • Agentic RAG, memory, and planning workflows with LangGraph & CrewAI • Strands-based flows with observability using OTEL & Arize • Evaluation with LLM-as-judge and cost/performance regressions • Built with Bedrock, S3, Step Functions, and more

GitHub: https://github.com/aws-samples/sample-agentic-frameworks-on-...

Would love your thoughts — feedback, issues, and stars welcome!

Hey HN,

I tend to use printf-style debugging as my primary troubleshooting method and only resort to gdb as a last resort.

While I like its ease of use printf debugging isn't without its annoyances, namely removing the print statements once you're done.

I used to use trace-level logging from proper logging libraries but adding trace calls in every corner quickly gets out of control and results in an overwhelming amount of output.

To scratch my own itch I created dlg - a minimal debugging library that disappears completely from production builds. Its API exposes just a single function, Printf [1].

dlg is optimized for performance in debug builds and, most importantly, when compiled without the dlg build tag, all calls are eliminated by the Go linker as if dlg was never imported.

For debug builds it adds optional stack trace generation configurable via environment variables or linker flags.

GitHub: https://github.com/vvvvv/dlg

Any feedback is much appreciated.

[1]: Actually two functions - there's also SetOutput.