Show stories

Hi HN!

I'm the author of an Elixir Agent Framework called Jido. We reached our 2.0 release this week, shipping a production-hardened framework to build, manage and run Agents on the BEAM.

Jido now supports a host of Agentic features, including:

- Tool Calling and Agent Skills - Comprehensive multi-agent support across distributed BEAM processes with Supervision - Multiple reasoning strategies including ReAct, Chain of Thought, Tree of Thought, and more - Advanced workflow capabilities - Durability through a robust Storage and Persistence layer - Agentic Memory - MCP and Sensors to interface with external services - Deep observability and debugging capabilities, including full stack OTel

I know Agent Frameworks can be considered a bit stale, but there hasn't been a major release of a framework on the BEAM. With a growing realization that the architecture of the BEAM is a good match for Agentic workloads, the time was right to make the announcement.

My background is enterprise engineering, distributed systems and Open Source. We've got a strong and growing community of builders committed to the Jido ecosystem. We're looking forward to what gets built on top of Jido!

Come build agents with us!

Title: Show HN: PageAgent, A GUI agent that lives inside your web app

Hi HN,

I'm building PageAgent, an open-source (MIT) library that embeds an AI agent directly into your frontend.

I built this because I believe there's a massive design space for deploying general agents natively inside the web apps we already use, rather than treating the web merely as a dumb target for isolated bots.

Currently, most AI agents operate from external clients or server-side programs, effectively leaving web development out of the AI ecosystem. I'm experimenting with an "inside-out" paradigm instead. By dropping the library into a page, you get a client-side agent that interacts natively with the live DOM tree and inherits the user's active session out of the box, which works perfectly for SPAs.

To handle cross-page tasks, I built an optional browser extension that acts as a "bridge". This allows the web-page agent to control the entire browser with explicit user authorization. Instead of a desktop app controlling your browser, your web app is empowered to act as a general agent that can navigate the broader web.

I'd love to start a conversation about the viability of this architecture, and what you all think about the future of in-app general agents. Happy to answer any questions!

I built Poppy as a side project to help people keep in touch more intentionally. Would love feedback on onboarding, reminders, and overall UX. Happy to answer questions.

Hi HN,

I thought it would be fun to plot a traceroute on a map to visually see the path packets take. I know this idea has been done before, but I still wanted to scratch that itch.

The first version just let you paste in a traceroute and it would plot the hops on a map. Later I discovered Globalping (https://globalping.io), which allows you to run traceroutes and MTRs from probes around the world, so I integrated that into the tool.

From playing around with it, I noticed a few interesting things:

• It's very easy to spot incorrect IP geolocation. If a hop shows 1–2 ms latency but appears to jump across continents, the geolocation is probably wrong.

• Suboptimal routing is sometimes much easier to notice visually than by just looking at latency numbers.

• Even with really good databases like IPinfo, IP geolocation is still not perfect, so parts of the path may occasionally be misleading.

Huge credit to the teams behind Globalping and IPinfo — Globalping for the measurement infrastructure and IPinfo for the geolocation data.

Feedback welcome.

AI coding agents generate decent code. The problem is everything around the code - checking progress, catching drift, deciding if it's actually done. I spent months trying to make autonomous agents work. The bottleneck was always me.

Attempt 1 - Claude/GPT directly: works for small stuff, but you re-explain context endlessly.

Attempt 2 - Copilot/Cursor: great autocomplete, still doing 95% of the thinking.

Attempt 3 - continuous agents: keeps working without prompting, but "no errors" doesn't mean "feature works."

Attempt 4 - parallel agents: faster wall-clock, but now you're manually reviewing even more output.

The common failure: nobody verifies whether the output satisfies the goal. That somebody was always me. So I automated that job.

OmoiOS is a spec-driven orchestration system. You describe a feature, and it:

1. Runs a multi-phase spec pipeline (Explore > Requirements > Design > Tasks) with LLM evaluators scoring each phase. Retry on failure, advance on pass. By the time agents code, requirements have machine-checkable acceptance criteria.

2. Spawns isolated cloud sandboxes per task. Your local env is untouched. Agents get ephemeral containers with full git access.

3. Validates continuously - a separate validator agent checks each task against acceptance criteria. Failures feed back for retry. No human in the loop between steps.

4. Discovers new work - validation can spawn new tasks when agents find missing edge cases. The task graph grows as agents learn.

What's hard (honest):

- Spec quality is the bottleneck. Vague spec = agents spinning. - Validation is domain-specific. API correctness is easy. UI quality is not. - Discovery branching can grow the task graph unexpectedly. - Sandbox overhead adds latency per task. Worth it, but a tradeoff. - Merging parallel branches with real conflicts is the hardest problem. - Guardian monitoring (per-agent trajectory analysis) has rough edges still.

Stack: Python/FastAPI, PostgreSQL+pgvector, Redis (~190K lines). Next.js 15 + React Flow (~83K lines TS). Claude Agent SDK + Daytona Cloud. 686 commits since Nov 2025, built solo. Apache 2.0.

I keep coming back to the same problem: structured spec generation that produces genuinely machine-checkable acceptance criteria. Has anyone found an approach that works for non-trivial features, or is this just fundamentally hard?

GitHub: https://github.com/kivo360/OmoiOS Live: https://omoios.dev

I’ve spent the last few years building AgnosticUI. It started as a CSS-first monorepo with logic manually duplicated across framework packages. It turned into a maintenance nightmare.

I recently completed a total rewrite in Lit to align with web standards and unify the core. One major architectural shift was moving to a "Source-First" model. Instead of a black box in node_modules, the UI source lives in your local project workspace.

This makes the components fully visible to LLMs, preventing the hallucinations common when AI tries to guess at hidden library APIs. I wrote a technical post-mortem on Frontend Masters detailing the hurdles of this migration (Shadow DOM a11y, Form Participation, and @lit/react vs React 19): https://frontendmasters.com/blog/post-mortem-rewriting-agnos...

Here's echo.html, a project I've been working on for almost a year! It's a tool to take notes, connect them, and save/share them as a single file. Imagine a mix between Feather Wiki and Roam but with commands like on emacs. Hope you like it!

https://github.com/vnglst/stacked-game-of-life

Built this in ~4 hours with zero coding background. Tracks a few economy angles of the largest acute shipping disruption since WWII.

LLM agents often place raw JSON tool outputs directly in the prompt. After a few tool calls, earlier results get compacted or truncated and answers become incorrect or inconsistent.

I built Sift, a drop-in MCP gateway that stores tool outputs as local artifacts (filesystem blobs indexed in SQLite) and returns an `artifact_id` plus compact schema hints when responses are large or paginated.

Instead of reasoning over full JSON in the prompt, the model runs a small Python query:

    def run(data, schema, params):
        return max(data, key=lambda x: x["magnitude"])["place"]

Benchmark (Claude Sonnet 4.6, 103 questions across 12 datasets):

- Baseline (raw JSON in prompt): 34/103 (33%), 10.7M input tokens

- Sift (artifact + code query): 102/103 (99%), 489K input tokens

Open benchmark + MIT code: https://github.com/lourencomaciel/sift-gateway

Install:

    pipx install sift-gateway
    sift-gateway init --from claude

Built an open-source voice skill for AI agents with real phone conversations via OpenAI Realtime API + Twilio SIP. Native speech-to-speech, no STT-LLM-TTS chain, sub-200ms latency. Features: inbound/outbound calls, tool calling mid-conversation, recording, transcription, session bridging, health monitoring, metrics, call history API. Use case: missed-call auto-callback for appointment booking ($2,100 avg lost per missed call). Tech: Python + Node.js, 97 tests, MIT licensed, 5-min quickstart.

SpiderSuite is a comprehensive digital marketing platform that offers a range of tools and services to help businesses improve their online presence, including website design, search engine optimization, social media management, and advertising solutions.

Vertex is a 1kloc SPA framework containing everything you need from React, Ractive-Load and jQuery while still being jQuery-compatible.

vertex.js is a single, self-contained file with no build step and no dependencies.

Also exhibits the curious quality of being faster than over a decade of engineering at Facebook in some cases: https://files.catbox.moe/sqei0d.png

I have used this tool privately since 2011 to manage directory jumping. While it is conceptually similar to tools like z or zoxide, the underlying ranking model is different. It uses a power-law convolution with the time series of cd actions to calculate a history-aware "frecency" metric instead of the standard heuristic counters and multipliers.

This approach moves away from point-estimates for recency. Most tools look only at the timestamp of the last visit, which can allow a "one-off" burst of activity to clobber long-term habits. By convolving a configurable history window (typically the last 1,000+ events), the score balances consistent habits against recent flukes.

On performance: Despite the O(N) complexity of calculating decay for 1,000+ events, query time is ~20-30ms (Real Time) in ksh/bash, which is well below the threshold of perceived lag.

I intentionally chose a Logical Path (pwd -L) model. Preserving symlink names ensures that the "Name" remains the primary searchable key. Resolving to physical paths often strips away the very keyword the user intends to use for searching.

The article discusses the development of a PHP extension for the Rust compiler, allowing Rust code to be executed within PHP applications. This integration aims to leverage Rust's performance and safety benefits to enhance the capabilities of PHP-based web applications.

The podcast-cli project is a command-line interface for downloading and managing podcasts, allowing users to search, subscribe, and download episodes from various podcasts using a simple and efficient interface.

DevTrack is a web application that helps developers manage their projects and tasks. The platform provides features such as project planning, task tracking, team collaboration, and progress reporting.

coroTracer is an open-source contact tracing tool that utilizes Bluetooth Low Energy (BLE) technology to track potential COVID-19 exposure. The system aims to provide a privacy-preserving solution for tracking and notifying individuals who may have been in close contact with confirmed COVID-19 cases.

I built Anaya to solve a problem I kept seeing: India's DPDP Act is now enforceable (rules notified Nov 2025, deadline May 2027) but compliance is a code problem, not just a legal checklist. No tooling existed for it. Ran it on Saleor (open-source Django e-commerce, 107 models): found 4 violations in 82 seconds — no consent mechanism, 70 PII fields stored plaintext, zero DELETE endpoints for any PII model.

pip install anaya && anaya compliance .

Code: https://github.com/sandip-pathe/anaya-scan

Happy to discuss the AST parsing approach or the DPDP section analyser design.

Hi HN,

I’m Padam, a developer based in Dubai.

Over the last 2 years I’ve been experimenting with the idea that AI inference might not require GPUs.

Modern LLM inference is often memory-bound rather than compute-bound, so I built an experimental system that virtualizes GPU-style parallelism from CPU cores using SIMD vectorization and quantization.

The result is AlifZetta — a prototype AI-native OS that runs inference without GPU hardware.

Some details:

• ~67k lines of Rust • kernel-level SIMD scheduling • INT4 quantization • sparse attention acceleration • speculative decoding • 6 AI models (text, code, medical, image,research,local)

Goal: make AI infrastructure cheaper and accessible where GPUs are expensive.

beta link is here: https://ask.axz.si

Curious what HN thinks about this approach.

I think this is apropos of the "Show HN" tag, as the post is explanatory and the entire codebase this little side-story use case discussed in TFA is in the repo and free to use. (I'd be pleased if you did!)

In the post, as I tried to capture in the title submitted, I outline my journey of exploration, when I became determined to make GitHub-Flavored Markdown display my text, with color, style and alignment of my choosing, which as I discovered after setting out to do so, the inability to do such a thing outside of fenced blocks with pre-defined syntax highlighting is a well-known condition, which is met with "works as intended" response because, well, GitHub doesn't want their repos looking like MySpace or Geocities or presenting security risk exposure by allowing arbitrary html/CSS styling. Sure, I should have used GitHub Pages to build a page from my Markdown using Jekyll, which is a supported way to control the styling of your own documents in your repo, but where's the fun in that?

The linked post documents the workaround I arrived at, which became an output target format that nobody has ever asked for from my ASCII line-Art diagramming tool. I thought some here might appreciate the documentation of "wasting my time so you don't have to" on a technical solution for a problem I probably just shouldn't have cared about and moved on.

When the LLM so ahh you lowk take over its job

The article discusses the redesign of Shuffle's website to better showcase the company's AI-powered no-code platform. It highlights the key goals of the redesign, such as improving user experience, showcasing Shuffle's capabilities, and aligning the website with the brand's identity.

I built a voice agent from scratch that averages ~400ms end-to-end latency (phone stop → first syllable). That’s with full STT → LLM → TTS in the loop, clean barge-ins, and no precomputed responses.

What moved the needle:

Voice is a turn-taking problem, not a transcription problem. VAD alone fails; you need semantic end-of-turn detection.

The system reduces to one loop: speaking vs listening. The two transitions - cancel instantly on barge-in, respond instantly on end-of-turn - define the experience.

STT → LLM → TTS must stream. Sequential pipelines are dead on arrival for natural conversation.

TTFT dominates everything. In voice, the first token is the critical path. Groq’s ~80ms TTFT was the single biggest win.

Geography matters more than prompts. Colocate everything or you lose before you start.

GitHub Repo: https://github.com/NickTikhonov/shuo

Follow whatever I next tinker with: https://x.com/nick_tikhonov

Timber is a lightweight, high-performance logging library for Java and Kotlin that provides a simple and flexible API for logging messages. It supports multiple logging backends, including Logcat, Timber, and SLF4J, and offers features such as tree-structured logging and custom tag generation.

I built qlog because I got tired of waiting for grep to search through gigabytes of logs.

qlog uses an inverted index (like search engines) to search millions of log lines in milliseconds. It's 10-100x faster than grep and way simpler than setting up Elasticsearch.

Features: - Lightning fast indexing (1M+ lines/sec using mmap) - Sub-millisecond searches on indexed data - Beautiful terminal output with context lines - Auto-detects JSON, syslog, nginx, apache formats - Zero configuration - Works offline - Pure Python

Example: qlog index './logs/*/*.log' qlog search "error" --context 3

I've tested it on 10GB of logs and it's consistently 3750x faster than grep. The index is stored locally so repeated searches are instant.

Demo: Run `bash examples/demo.sh` to see it in action.

GitHub: https://github.com/Cosm00/qlog

Perfect for developers/DevOps folks who search logs daily.

Happy to answer questions!

It it always bugged me when I read or share an article, the discussion lives separately from the article. I imagined being able to add Google-Docs or Notion style comments on any website. We save a snapshot of the website and allow adding discussions that live side-by-side and directly reference parts of the article.

HN articles are automatically indexed in https://cooo.link/hackernews

and you can add any website, PDFs on https://cooo.link/

Built with SvelteKit, SingleFile(for archiving page), Railway. Solo dev. Would love feedback if you found it interesting! Thanks

As many of us shift from being software engineers to software managers, tracking changes the right way is growing more important.

It’s time to truly understand and master Git.