Show HN for July 30, 2025

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

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!

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 HN! My name is Christian, and I’m the co-founder of https://frigade.ai. We’ve built a powerful 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 [email protected] 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?

I've been working on this for a while now, and I'm happy to share!

I've been into launching weather balloons for a few years. One aspect of the hobby that really drew me in was the tracking side of things. Tracking systems let you follow the balloon's position throughout the flight and, most importantly, know exactly where it lands so you can recover the instrumentation. APRS is what I started out using during my first few years in the hobby, after I got my amateur radio license in 2020 (W0MXX). I designed a few small boards using the trackuino (https://github.com/trackuino/trackuino) firmware (while breaking 3 $70 radio modules along the way).

I then got into recovering radiosondes, which are launched twice per day by the NWS and can be reprogrammed using RS41ng (https://github.com/mikaelnousiainen/RS41ng) to run many amateur radio tracking protocols. I was a bit dissatisfied with how large and heavy the radiosonde trackers were, so I designed my own tracking system, called Tiny4FSK.

Tiny4FSK is a flight computer with built-in tracking using the Horus Binary v2 tracking system. This protocol was developed by the Project Horus team specifically for high-altitude balloons, and it brings features like high transmit rates, forward error correction, and excellent weak-signal performance in an open source package. It's designed to be as compact as possible and can run on a single AA battery for upwards of 17 hours.

The main board comes with header rows that allow for out-of-the-box expansion. I developed a shield that supports the BME280 environmental sensor, the ICM-20948 9-axis IMU, and more via the Qwiic connector. It also features an OLED display for basic diagnostics.

While I've pretty much polished the main tracking procedures (and have tested on multiple flights), I'm still developing the IMU code using a lightweight Kalman filter. Additionally, there isn't yet a wide network of Horus Binary decoding stations like the APRS network has (I-gates), but I hope that by promoting this protocol, more stations will pop up. This means that if you're not in an area with many receive stations, you'll need to set up your own using either Horus-GUI (https://github.com/projecthorus/horus-gui) or horusdemodlib (https://github.com/projecthorus/horusdemodlib).

One issue I’m still working on is improving RF signal strength. Although the protocol is decodable in very low-noise environments, the transmit power appears to be lower than that of a typical radiosonde. This could be due to several factors: limited current on a weak power source (signal is stronger when powered from a bench supply), off-tuned filtering/matching, or not paying enough attention to the antenna. I'm planning to run more simulations to figure this out. That said, the signal is still decodable from the ground even at max altitude (~100,000 feet).

On the more technical side, Tiny4FSK uses: - the SAMD21 microcontroller, which is an ARM Cortex-M0+ MCU - the TPS61200 boost converter, which is adjusted to output 3.3v - Si4063 radio module, which I use on the 70cm band - ATGM336H gps module - pretty cheap GPS module which works in airborne mode (>18km) - integrated BME280 temperature, pressure, and humidity sensor The code uses the Arduino framework to make it accessible to beginners.

All flights using Horus Binary v2, including reprogrammed radiosondes, other custom trackers, and Tiny4FSK show up in real-time on Sondehub Amateur (https://amateur.sondehub.org). Flight data can be found in the /Media/Data folder on Github (there's several missing flights on there though).

Thanks for reading, hope I didn’t mess anything up too badly in the post! -Max

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!

Steve from Temporal here. Temporal is an MIT open source project for reliable execution at scale. I adapted+extended some of OpenAI's Agents SDK samples to integrate with Temporal.

These demo agents can survive process crashes, scale to millions of executions in parallel and have easy-to-implement human interactivity. Just add a couple of Python decorators to your OpenAI agent code, run Temporal workers and you're ready to go.

Check the video I did with OpenAI showing this in action (it's linked in the repo).

OpenAI actually use us for ChatGPT Images and also their Codex code writing agent so I figure this may be a viable path for others to code something easy that's also reliable at scale.

Happy to answer questions.

It started off with the simple idea to cram together the accountability of Patreon (quit when you want) with the coordinated action of Kickstarter (thresholds).

The MVP behind the link demonstrates the very first iteration of this concept.

The second big idea was keeping power with the backers. Let communities of users freely move between different people who make stuff instead of being captives like with Star Citizen. This also lets creators focus on making stuff instead of selling the next Solar Roads.

Along the way I realized that there are opportunities where the world can deliver a ton of value for not that much cost but the money still can't flow. Why can't the capital move? It's because of value capture difficulty or value production uncertainty. However, the downstream often doesn't care. Consumers and downstream businesses are not sensitive to the profitability of upstream. They want stuff and they don't want to wait on startups to figure out how to bootstrap to profitability to get out of the chicken and egg dilemmas.

Deep tech and open IP are those kinds of things. Welcome to https://positron.solutions. Our mission is to connect demand for downstream value creation to upstream enabling technologies.

This Production Finance concept is very broadly applicable. This can be a remedy to the extremely poor monetization of independent media. My main point is that these things are worth building, and PrizeForge is a feature complete product the moment that we realize that we want things like PrizeForge to exist and that this MVP is a way for us to get there faster.

For now, I want to focus on the consumer open source market because it's a deeply distressed market where billions of willing dollars are stuck behind the volunteer's dilemma. It's also a simple market because there's no IP law to juggle. Open source has a strong tradition of killing stupid competition and delivering lots of indirect value that pays big dividends.

In getting ready for this moment, I pulled together a modest YouTube following, some Github stars, and developed my own takes on where open source thinking needs to go to win. I will be inviting my Github Sponsors over pretty soon and, above all, introducting features on our sub-Reddit to get the iteration dynamo going.

The MVP is a full-stack Rust application. It has a Leptos reactive frontend and Axum on the backend, talking to Postgres and NATS. I'll have a lot to say about that while courting some communities and engineers. https://positron.solutions/careers

I came up with the binary fragmentation idea while developing. I was just going to truncate. I chopped out two planned features becuase they were going to require fixed-point calculations. I'm glad I did because last night I crafted a bad kubernetes secret and discovered it only because a header unwrap in Stripe's library was panicking. I am toasted.

The Elastic Fund Raising feature was easier to get an MVP going, but our communication and decision delegation tools are probably going to be more impactful. We need social decision systems designed for open communities, from first principles, for the information age, not the age of horses and ballots.

I need to cut chase for now. I've got several communities I need to pull together. I've done a lot of ground work to build up my reputational constraints, figuring out video production, and talking to people to find out what clicks.

Log in, top-up, and enroll. The system is pre-pay. Funds are not truly mine until matched and I don't want to go to SBF jail, so you can trust me to implement logouts and refunds as soon as possible. Follow my socials and go be social yourselves. It's not about what you can do. It's about what millions of angry gamers who want VKD3D right now can do if only they have a better Kickstarter.

I wanted to be able to code with Claude anytime, anywhere — walking, commuting, or at a café. So I built a browser-based terminal for Claude Code!

- Zero-config, instant REPL

- Works on mobile and tablets (Chrome, Safari)

- WASM-powered performance

Let me know what you think.

I made an app for controlling a vintage Macintosh from a modern Mac, using an Arduino to translate between the modern Mac and Apple Desktop Bus.

Hi HN, I'm Hemang from Clidey, and we are working on Docucod. Docucod is a tool that automatically generates and maintains documentation from any repository.

* What is the problem? * My co-founder and I have both worked in large corporates like J.P. Morgan, Morgan Stanley, smaller companies like Palantir, and continuously see the issues that stem from unmaintained documentation.

Most codebases are under-documented, comments are sparsed, types aren't always obvious, and there's often a lot of knowledge that is forgotten as time goes on.

The deeper you go, the harder it gets to understand how things work. This slows down onboarding, wastes time during debugging, and increases the chance of things breaking.

Until today, we have been running pilots with small to medium sized companies and startups tweaking the product and gaining lots of feedback.

Today we want to open it up to the public with a release of the generation service!

* Try it out! * Go to https://docucod.com/oss and put your repository URL there. Once generated, the link will be visible.

You can also put the prefix url in front of the repo url: https://docucod.com/docs/<repo-url> (example: https://docucocd.com/docs/https://github.com/clidey/whodb)

Please note this will work only for public repos up to 100MB.

How it works: Docucod analyzes the codebase, parses files, comments, types, examples, and the readme, then builds a static documentation site you can browse immediately — no config, no setup.

It tries to surface useful context automatically so you don’t have to read the code line by line to figure out what’s going on.

There is diagram generation with Mermaid, and we are working on generating images and later videos!

The publishing is done with our own static site builder called Dory ([https://github.com/clidey/dory](https://github.com/clidey/dory)).

It handles parsing, structure extraction, and HTML generation. Dory has been built with handling AI-generated MDX in mind, which is an interesting hurdle to overcome.

We're still fleshing it out, so PRs and feedback are very welcome.

What’s next: Right now we support public GitHub repos (private support coming). We’re also working on features like code search across the docs, customized responses based on the user's query, better navigation, theme customization, and integration with CI pipelines.

If you check it out, I’d really appreciate your feedback — both the good and the bad. Does it solve a real problem for you? What’s confusing, missing, or just not helpful?

Thanks!

Hi all, I'm Ivan, and together with Alex, we're building a diagram visualization tool for codebases.

Alex and I are devs, and we've noticed that recently we've been super productive at writing code (prompting :D). But when it comes to understanding big systems, prompting doesn't work that well — for that, diagrams are best imo. Most tools out there don't scale to big projects (e.g. PyTorch), so we're building CodeBoarding — a recursive visualizer for codebases. It starts from the highest level of abstractions and lets you dive deeper. We use static analysis and LLM agents. The control-flow graph is our starting point, and we validate the LLM's analysis against the static analysis output. LLMs alone often hallucinate or apply familiar architectural patterns that don't actually exist in the code.

Since this is a concise representation of a codebase, we also added an MCP-server to provide our docs for the libs your project depends on — reducing hallucinations and avoiding blowing up the context window. The vision: With agents writing more and more code, we think we also need a concise representation for it — diagrams. But for that to work, the diagrams have to be accurate, and that's why static analysis has to take part in the fun ;d.

Would love to hear what you think about diagram representations for code, what problems you've run into with hallucinations while vibe-coding (even with tools like gitingest/context7), and any general feedback :)

Sharing something that I’ve been working on:

I made a save-later app for all my bookmarks. I save links throughout the week and, every Sunday morning, the app sends me a personalized recap with: -patterns and themes that connect my week to my broader interests -a nudge toward links I saved but never revisited -one reflective question to help me decide what else might be worth exploring

I was inspired by older read-later apps like Instapaper. I wanted to make something minimalist, so it’s just a simple feed of your links (with tags and annotations linked to each link) and it is set up to ingest all kinds of content, not just text. I also did want it to be bloated as the full-fat AI stuff you see recently. So this is a simpler and more proactive take on the concept of a bookmarking app.

Imagine if Pocket and Spotify Wrapped had a baby.

I also personally enjoy using the chat to find links across subjects and sources with context, like “Show me the 5 links on travel i’ve returned to the most” or “all recipes with porcini mushrooms” or “show me everything on Topic X i’ve made the most notes on.”

I’ve posted about this on HN before, always had great feedback. Happy to answer any questions. (I’m not technical, I'm a writer/ filmmaker.)

Meet Dory - A quick way to cycle through apps without moving your hand from the mouse or keyboard - and without needing to remember any shortcuts.

Click your middle mouse button - or the right Command key if both hands are on the keyboard - and type the first letter of the app’s name.

Find apps using the first letter, middle letters, acronyms, or similar names.

If multiple apps share that letter, just keep tapping it to cycle through them.

You can also press the middle mouse button and start typing the app’s name directly.

Prefer tapping over holding? No problem. With Press Mode, you can open Dory’s sleek UI using a global shortcut.

Dory works right out of the box - and over time, it learns which apps you use most and prioritizes them.

No extra shortcuts.

No setup. Nothing to remember.

---

It's currently $3.99 on the Mac App Store (One-time purchase. No subscription.)

Also, just a heads-up: the current price won't last much longer.

If you've been thinking about getting Dory, now might be the perfect time.

I built this after getting tired of setting up full-blown frameworks like Docusaurus or Mintlify just to render a few markdown files for my open source projects.

Docmd is a lightweight CLI tool that turns .md files into responsive, themed HTML docs. Built-in components, plugin support, and GitHub Pages-ready.

Try it: https://docmd.mgks.dev Repo: https://github.com/mgks/docmd

Hey HN, I used to be a frontend engineer, but for the past two years, I've been working as an independent developer. I'm building tools to solve problems I encounter in my daily workflow.

Every day, I use F12/devtools to debug web pages. Honestly, I often just want to see how an element is written or which styles are affecting my layout. In 2024, I upgraded to a new laptop with a smaller screen (14") compared to my old one. Now, whenever I press F12, the webpage gets squeezed, sometimes even switching to mobile view. This frustration inspired me to create GetEles, named after JavaScript functions like getElementsBy*.

What can GetEles do?

1. Quickly get website info: title, description, color scheme, resources, etc. 2. Quickly inspect element details: classes, inline styles. 3. Quickly locate elements (I've traversed the DOM for you!). 4. Quickly convert element styles to Tailwind CSS. 5. Precisely measure the distance between any two elements. 6. Quickly export screenshots of elements or the entire page. 7. Get page load times and performance info...

GetEles is free to use, though some advanced features require a subscription. Even so, I highly recommend trying out the experience on the official website first – it includes over 90% of the functionality.

Head over to the website and click "Try it out":

https://geteles.com

Hi HN,

I've created a simple, non-commercial web tool called the Dahej (Dowry) Calculator.

Growing up hearing stories within my community about the immense pressure and financial ruin caused by the dowry system in India, I wanted to find a way to talk about this difficult topic. Direct confrontation often shuts down dialogue, so I chose satire as a way to approach it.

The calculator is intentionally absurd; it generates a monetary 'worth' based on real-world (and often ugly) factors like profession, salary, and even caste. The goal isn't to be accurate, but to be a conversation starter. It's an educational tool designed to hold up a mirror to a practice that treats marriage like a transaction.

There are no ads, trackers, or sign-up requirements. It's just a simple page built with React.

I'm here to answer any questions and would love to hear your feedback on using satire and technology for social commentary.

Thanks for checking it out.

Since Qardio went bankrupt, Qardio Arm users were left with paperweights. I've built this app to let myself and other users left in the lurch to give back life to their device and continue monitoring their health. I'm looking for feedback, and will be planning to release it on the app store.

I built SubSlayer to solve a personal pain point: I was paying for multiple tools I barely used, and didn’t even realize it.

SubSlayer helps you: – Track your active subscriptions – Set cancel reminders – Simulate how much you could save

I built it as a solo founder. Still very early, and I’d love feedback from the HN community, especially on what features would be most useful next.

https://subslayer.app

Hi HN!

I'm a solo builder and a plant lover. I kept struggling to identify my houseplants correctly, and even when I knew their names, I wasn’t always sure how to care for them properly. Watering too much, not enough light… you know the drill.

So I built PlantGenieAI, an iOS app that does four things:

1. Instantly identifies plants from a photo (95%+ accuracy)

2. Gives tailored care guides based on species

3. Lets you chat with an AI assistant — ask anything like: “Why are my pothos leaves turning yellow?” “How much sunlight does a fiddle leaf fig need?”

4. Smart reminders for watering, fertilizing, and more

I originally built this for myself, but it's now live on the App Store: https://apps.apple.com/us/app/plantgenieai/id6747911595

Would love feedback — on product direction, UX, or growth ideas.

Thanks for reading, and happy plant parenting!

Hey folks,

I just released a new CLI tool called gmap, built in Rust, focused on exploring Git history visually and efficiently from your terminal.

Highlights: • Heatmap view: weekly commit activity with churn and delta stats • Filetype breakdown: see which file extensions are most active • Authorship insight: per-week top contributors • Timeline and trends: sparkline and stats over time • TUI mode (–tui): navigate interactively, search, filter, view stats • Export mode: get all Git stats as JSON for further processing

Install with:

cargo install gmap

Or check it out here: https://github.com/seeyebe/gmap

Let me know what you think. Feedback welcome!