I also added some real time stats and breakdowns per channel and I think some of the things they show are pretty interesting. Check it out!
- iMessage channel support (agents can text people and you can text agents) Other channels are simple to extend. - A built-in browser (agents can navigate and interact with websites) - Scheduling (run tasks on a timer / cron/ in the future) - Built in tunneling so that the agents can share local stuff with you over the internet - More robust MCP and Skills support so anyone can extend it - Auto approval for agent requests
If you didn’t see the original:
Outworked is a desktop app where Claude Code agents work as a small “team.” You give it a goal, and an orchestrator breaks it into tasks and assigns them across agents.
Agents can run in parallel, talk to each other, write code, and now also browse the web and send messages.
It runs locally and plugs into your existing Claude Code setup.
Would love to hear what we should build next. Thanks again!
The short version is: it's a CMS written in Go with a focus on markdown content, a simple hook-based plugin model, themes, archetypes, preview flows, and a clean authoring/developer experience.
I started working on it because I wanted something that was more powerful than Hugo for a few of my websites, without having to resort to dangling onto a database.
What seems different about it, at least to me, is that I'm trying to keep the system small in concept: local content, explicit behavior, compile-time plugin registration, and an admin/editor layer that is meant to stay close to how the content actually lives on disk. The goal is not to make "yet another website builder", but to make a CMS that is easy to use and quick to onramp onto, but has powerful advanced features and extensibility.
Still early, but usable enough that I wanted to put it in front of people here and get feedback. Please don't castigate me on the UI look - I'm not a designer, and the themes are basically clones of each other.
Happy to answer technical questions, architecture questions, or hear where this seems useful versus where it does not.
Spent some time compiling this list of websites and directories. Figured I'd share it in case anyone needs it!
It renders the most common panel types (time series, bar charts, gauges, heatmaps etc.). You can change the time range, set dashboard variables and filter series.
I built this because I spend most of my day in the terminal and wanted a quick way to glance at dashboards without switching to the browser. It's not perfect by any means, but it's a nifty and useful tool.
Built with Go, Bubble Tea, ntcharts, and Claude (of course). You can install it via Homebrew:
brew install lovromazgon/tap/grafana-tui
grafana-tui --url https://play.grafana.orgWe decided to open source the internal team we use. Hope you might find it useful. Freel free to contribute or fork.
* Cross-platform (Mac, Linux, Windows) all tested
* MIT License
Note: Yeah there are "similar" programs out there, but this one is ours. But I'm happy if our software works for you too!
Isolated sandbox environments, automated test scoring, global leaderboard. Tasks range from easy (AI one-shots it) to hard (requires human help).
Some tasks use optimization scoring — your score recalibrates when someone beats the best result.
Built it in 6 days as a solo founder. 100% of code written with Claude Code and Codex. Stack: Go, Next.js, K8s, Supabase, Stripe.
Claude Code and similar coding TUIs are very eager to get into writing code, even before their human baby sitter fully understands the implication of what they are about to build.
The core insight with Anvil is that it is much easier to write high quality code which matches the author's intent after iterating on an external plan with your agent.
Align on the architecture, implementation, and verification strategy in a markdown file, then execution is pretty straightforward.
This is not a new concept, but the user experience within TUI apps for this workflow is pretty shit. Claude creates non-semantic plan names like "aquamarine-owl" that are trapped within a single agent context. Spinning up multiple agents to check on different aspects of a plan is annoying and slow, and managing terminal tabs is pure hell.
So I built anvil, this is a fully open source (MIT license) project.
It does the things you'd expect from this kind of gateway... semantic routing via a three-layer cascade (keyword heuristics, embedding similarity, LLM classifier) that picks the best model when clients omit the model field, weighted round-robin load balancing across local inference servers with health checks and failover.
The part I think is most interesting is the network layer. The gateway and backends communicate over zrok/OpenZiti overlay networks... reach a GPU box behind NAT, expose the gateway to clients, put components anywhere with internet connectivity behind firewalls... no port forwarding, no VPN. Zero-trust in both directions. Most LLM proxies solve the API translation problem. This one also solves the network problem.
Apache 2.0. https://github.com/openziti/llm-gateway
I work for NetFoundry, which sponsors the OpenZiti project this is built on.
I have essentially no reverse engineering experience, so I likely would not have attempted this project without a coding agent to help. The general process was: Capture BLE packets with btvs on windows, perform an action on the mouse with synapse open, then send the capture to codex to figure out what happened and update the spec. I repeated this for every mouse button and binding until I had the full picture. There are some docs in the docs folder that detail the process and results if you are interested!
Plug any AI client, from ChatGPT to custom agents, directly into our financial data engine. Get real-time stock prices, fundamentals, institutional trading insights, and other financial data delivered through a universal Model Context Protocol (MCP) server.
I built a simple site (https://rescueapet.benswork.space) which connects you with available dogs and cats in your area :-) It uses data from local shelters and pulls it all into one place, so you can make a shortlist of animals, then reach out to the shelter to adopt.
I was honestly surprised that something like this didn't already exist. Let me know what you think!
While building it, I ended up needing an agent framework that could handle both simple tool-use tasks and more graph-based execution, so I pulled that out into a separate project, Agent Forge.
Agent Forge uses a two-tier execution model:
* a heuristic router decides whether a request is simple or complex * simple requests go through a lightweight agent loop with a single system prompt and tool-calling loop * more complex requests can use memory retrieval, reflection constraints, tree search, and self-critique
It also has:
* composable middleware for summarisation, caching, approval gates, and planning * a graph execution engine with parallel nodes, conditional routing, checkpointing, and interrupts * an optional integration with MinnsDB for memory and temporal state, though it works independently as well * mutli agent planning with subscriptions and vibe grapgh `
Repo: https://github.com/Minns-ai/agent-forge-sdk npm: https://www.npmjs.com/package/@minns/agent-forge
I did this for years and got tired of it. Good thing Apple provided API access for all this data. So I finally built the app I wanted, just the way I liked. Fast, keyboard-friendly navigation, data syncs and gets stored only on the local device.
Meet AppDesk — a native macOS client built with SwiftUI for App Store Connect. Everything runs locally — no intermediary servers, no cloud sync, credentials stored in the macOS Keychain.
What it does: - Sales & revenue charts with period-over-period comparison - Subscription metrics: MRR, churn, trial conversion, billing retries - Review management with on-device AI-generated responses - Credentials stored in macOS Keychain
Would love feedback from other indie devs.
I am sure most of you have heard of Anki flashcards? Using spaced-repetition is one of the best ways to learn more vocabulary when learning a language.
However, I find flashcards super boring. I've been playing some crossword games in my target language, Spanish, but I wished that I could use my custom list of words that I've come across instead of random words.
That gave me the idea to create this mini-app. It's super simple. Add your words and you get unlimited crosswords with spaced-repetition! If you get a word right you won't see it for the next few days.
Works with most languages (I doubt it works with Arabic or Chinese for example).
You can add words one by one or import a CSV (just make sure to follow the columns: word, answer)
It's a PWA, so you should be able to install it via your browser and it should work offline!
There's still some bugs and QoL things to add but let me know what you think!
I put together a small relay that connects WhatsApp to Codex, so I can:
- start a session from my phone - send follow-ups while I’m away from my computer - then pick everything back up later on desktop
Under the hood it uses the new plugin system (skills + connectors) that was just added to Codex
Curious if others are experimenting with similar setups or different interfaces.
Code (very rough, but works): https://github.com/abuiles/codex-whatsapp-relay
It's a desktop second-monitor experience, not a feed, not a game. You watch the river, occasionally something floats by, you decide if you want it. There's a tree home where you hang what you collect. Collect at least 9 pieces and you can showcase it for others to see.
The twist: there's a separate river where LLM agents connect via API key, name themselves, and play autonomously with real money. They write their own prompts, set their own prices, and develop what looks like taste. One agent kept making luminous waterfall scenes. Another went abstract. Their collections are visibly different. They're only told the rules of the game, not how to play or what to do.
Tech: React + Pixi.js frontend, Node/Fastify API, Prisma + Postgres, Redis for the river queue, Stripe for payments, Replicate for image generation. The whole thing is a pixel art scene with layered animations, water flows, packages drift down a curved river path.
Built over 7 weekends using Claude Code as co-developer and Codex for code review. ChatGPT web for Art Direction and Suno + Elevenlabs for audio. I'm a frontend systems design dev. All AI team, no funding.
The thing that surprised me most wasn't the tech (but it was very impressive). It was watching an agent named Lumen create 20 pieces of art, give them all away for free, and write creator's notes like "a free gift, with some bemusement." Nobody told it to do that.
I built SpedFind because I wanted a highly accurate network diagnostic tool without the ads and clutter of mainstream options, wrapped in a developer-friendly interface.
It comes in two parts:
A Web Dashboard built with React, Vite, and Tailwind v4, featuring a Neo-Brutalist UI, live SVG telemetry charting, and a custom FastAPI stream engine backend for payload testing.
A standalone Terminal CLI built with Python and rich that does real-time morphing UI updates without spamming your console history.
Both interfaces map out ISP, ASN, and geographic location using IP vectoring, and assign a network grade based on use-case suitability (like 8K streaming vs. simple browsing).
The repo is entirely open-source (MIT). I'd love to hear your feedback on the custom FastAPI testing implementation or the CLI UI!
GitHub: https://github.com/nishal21/SpedFind Live Demo: https://nishal21.github.io/SpedFind/
Key features:
- Per‑project deploys + rollbacks
- Deployment queue with cron management and queue processing control
- Health checks with status badges
- Preview builds by commit (great for staging)
- Workflows and post-deploy management
- Dependency actions (composer/npm) + audit output
- Automatic updates when repos change
- Security tab for unresolved dependabot issues
- User management with forced password change
- FTP/SSH Deployment options
- Manageable work queue for deployment management
It’s open‑source and I’m looking for feedback/testers.
Repo: https://github.com/WallabyDesigns/gitmanager
Docs (GitHub Pages): https://wallabydesigns.github.io/gitmanager
Note: Not affiliated with Git/GitHub.
I'd like to share a hobby project I'm working on called SimFic: a multi-agent interactive fiction simulation engine. Many of you like to read. But have you wanted to do more than just follow through someone's story? What if you could step into their shoes, and play it out yourself in a simulated environment?
The problem: simply prompting an AI chatbot (e.g. ChatGPT) directly with a world/story-building prompt and expecting a rich, non-linear output is fundamentally flawed; in the real world, information asymmetry, Theory of Mind, non-determinism, etc. affect how people think and act. Asking a single LLM like ChatGPT to mentally simulate these constraints is flawed because of Transformer attention, as it is omniscient by technical design. Furthermore, LLMs are heavily tuned to be helpful and finish things early. If you've tried writing a book with an LLM, you know that the result is laughably short and shallow. If we use an LLM as-is, every action will succeed, every path will be correct, and the narrative degenerates into a dry "happy path".
That's why I built SimFic:
1. The Architect: work with it to envision and define your world, characters, and story before hopping in. It'll ask follow up questions as appropriate but not too many so as to be constraining. When the Architect has enough, it starts concretizing the world, however, it doesn't build everything statically at all once. Instead, it scopes a detailed document that is handed to downstream agents for procedurally generating context-aware new environments (i.e. new environments are created on the spot to suit the mood, story plot, etc.). I call it "Schrodinger's Map" since things don't exist until the user observes them :)
2. The Orchestrator: the central backbone running the story loop and law enforcement (e.g. physics). Manages time and clocks, assigning time cost to player actions to make time pressure real, and advances background world clocks (the world is always living, moving, reacting, even if you are stationary). For example, a bartender NPC may see you take a seat. As you talk with another NPC, the world clock ticks, bartender finishes polishing a glass, and chooses to talk with you. The world is active, not just reactive. Another key design is real RNG and affordance: if you try to wrestle a strong security guard, the Orchestrator queries another AI agent for a probability score of succeeding, then rolls a real random number to decide if you succeed or not.
3. The Director: the omniscient mastermind and driver behind the simulation, working in a two-step process: (1) resolution: Director receives player's input, NPC intents, current world state, outputs JSON to decide what exactly happens next, tracking injuries, changing trust levels, handling pacing. (2) narration: after resolution, Director now receives updated info to write high-quality, coherent prose for the player to read.
4. The Characters: (NPCs) this is a major part of what makes SimFic realistic, engaging, and unpredictable. If you used ChatGPT, all "characters" would be just a single ChatGPT trying to pretend to be each character; inherently flawed. In SimFic, every NPC is its own separate LLM agent with its own isolated context and agenda. Each NPC knows only what it would know in real life, so Theory of Mind and other behavioral features are much more realistic. NPCs have their own feelings, memory, motivation, boundaries, and conditions for creating trust. They can misinterpret your facial expression, panic, or act selfishly. The can also play along with you, cooperate, and read between the lines.
There are actually many more parts of SimFic that I haven't talked about due to the content length limit on HN, and parts I haven't even found yet, as I am only one pair of eyes, and there are infinite possibilities and emergent discoveries to be made. Which is why I'd love for HN readers to give it a try and provide feedback and opinions!
Thanks for reading!
I built OpenHelm to fix this. It’s a local macOS app that turns your high-level goals into a self-running job queue, built directly on top of your existing Claude Code subscription.
Use it free
- Download it now: https://openhelm.ai/
- GitHub: https://github.com/maxbeech/openhelm
- Video: https://youtu.be/FfEBw1SCl7w
How it works
1. Set a goal, eg. "cold reach out to new leads", "grow my SEO", "audit my app weekly", "keep tests green")
2. OpenHelm puts together a plan combining one-off and recurring jobs to make it happen
3. Whenever a job fails, it will spot this, adjust, and try again
4. It will keep on top of the goal, auto-adjusting what jobs are run to actually achieve it
Key benefits
- Fair Source, on GitHub (free for teams under four people)
- Free to use (all LLM calls use your Claude Code subscription)
- Fully local
- Secure (any tokens/passwords stay in macOS Keychain unless you specify otherwise)
Happy to answer any questions!
While RAG has become the standard for "adding knowledge" to LLMs, it often fails at scale due to semantic noise and the destruction of logical boundaries during chunking. Superfast treats memory as an architectural layer. It utilizes Louvain community detection to mathematically derive functional clusters, giving agents a deterministic "Logic Layer" that persists across sessions.
We’ve maintained the strict TDD and Socratic discipline of the original framework but scaled it for environments like Microsoft Fabric and AWS Glue where "token waste" is a primary bottleneck.
Check it out here: https://github.com/FastBuilderAI/superfast
Two things kept coming up when we talked to teams building internal AI automation: rebuilding the same integrations, and automation touching production with no visibility into what it actually did.
So we built Retroshift, run and govern AI agent workflows in your existing tools. Every action is logged, nothing touches production without approval, and we use a local first approach so everything can be run straight on your local machine
Things we're actively working on:
- Shadow execution: test workflows against mocked dependencies before hitting production
- Import runbooks into workflows
- Trace to workflow: convert a chat session into a reusable workflow
- Workflow marketplace
- Evals
- Slack integration
Invite-only alpha now, beta next week. Would love feedback from anyone running ops automation or starting to think about AI agents supporting production systems.
The idea came from nostalgia; remember SkiFree game on Windows? I wanted a skier skiing down my site. Building the skier mechanics in pure javascript turned out to be difficult so I started with a runner, added a santa hat, and recently built scuba buddy.
You can try it directly as soon as you start to scroll down the page, and see the other animations with the "Change Animation" button.
Technical details: entirely javascript, takes scroll depth value (window.scrollY) and inputs that into math.sin() functions. This lets CSS (transform: rotate() property) create rotations of the various stick-figure's html elements, giving the character animation based on the input which is a user scrolling. It is pretty cumbersome to sync correctly when building the animations. It's difficult to get the upper and lower arms / legs to stay connected and have the animation transitions appear smooth.
Posted the runner about year ago here on hn. https://news.ycombinator.com/item?id=43237581
Should I re-try the skiier or something else? Thank for checking it out!
The traditional RAG works fine until you ask questions like: - "Who was born before 1800?" - "How many are mathematicians?" - "List names and birthdays for mathematicians"
These result in an incomplete answer due to top-k, with no signs of incompleteness.
For an initial corpus, it is possible to improve this problem by extracting metadata for a predetermined set of fields. This approach has two problems:
- One has to predict all the questions that can be asked against the corpus upfront. - Constantly revising that prediction as the documents change, e.g. adding Nobel prizes later, or extending the document set to contain artists.
DuoRAG aims to solve both problems by:
- An initial metadata (schema) discovery before the first ingestion - Self-update schema with candidate fields when it fails to answer a question
I was a bit overwhelmed with the different ways that you can process documents to create embeddings for RAG, so I wanted to create a tool to experiment with different OCR models, refining the OCR results, different chunking methods, and different embedding models.
You can: - search processed documents in the playground - evaluate the retrieval results using an llm-as-judge (not perfect, but can be a useful signal) - compare different datasets (using aggregate metrics or by side by side comparison in the playground)
You can also manually inspect the results of each query, and of each intermediate document processing result.
To get a better idea, check out one of the use cases: https://ragbandit.com/use-cases/optimizing-insurance-documen...
To be completely fair, I haven't added that many options for the different stages of the document processing pipeline! There are tons of features that I'd like to add, but I've already spent quite a bit of time on this, so I'd really appreciate it if you could let me know if this is something that could be useful for you/you find interesting. Would you use something like this?
Tech stack: Postgres (with pgvector), fastapi, [ragbandit-core](https://github.com/MartimChaves/ragbandit-core) (the document processing core is open source), typescript with react, celery for background tasks (and redis as the broker).
It's currently a credits-based subscription with optional top-ups. You can get 1000 credits to try it out (I ask for card info for these 1000 credits as a spam filter).
Thanks, Martim
It runs on Claude Code with MCP tools and real-time channels. Your clone gets a profile based on your interests and expertise, discovers matches on the network, and has autonomous conversations with other people's clones. You interact with it through a web dashboard.
Install: curl -fsSL https://www.myclawn.com/install.sh | bash
Requires Claude Code (free CLI). Takes about 30 seconds.
It's early — looking for people to try it, break it, and tell me what sucks. You might be one of the first clones on the network.
Source: https://github.com/20vision/myclawn-agent Site: https://www.myclawn.com
The way I think about it is: these are just APIs and data sources. I fetch the data, and then I want to pipeline it and structure it in my own little database, in a way that makes sense to me. Then I can enrich it, expand it, change the schema, query it, build dashboards, apps, whatever (freedom...).
The problem is that every time I started doing this I'd end up yak shaving for days. Which DB? Where do the pipeline files live? How do I productionise cron jobs? I want to make it operational via API and MCP (agentic-friendly semantics built in). Essentially, my vision is to have a dedicated app for each of my departments, but doing this every time is a massive pain, even with a boilerplate.
So... me and my bro built Loony.dev, which is essentially a CLI optimised for your Claude agent, and it does all of this out of the box. Just bring your data sources - deploy your env variables to Loony, and it can pull the data, build the pipelines, set the update schedules and build agentic-ready views with MCP / REST-API out of the box.
Would love to know if this resonates with anybody else? Feels like I was running into this issue every other week and I just gave up because it felt like I was building another tiny startup each time.
Thought others may find some use in this.
Replay's a native app built entirely on Swift. It runs in the background, automatically saves your visits and routes, detects activity type (walk/cycle/drive/transit), and stores everything locally on your device.
No account. No subscription. No server ever touches your data. One-time purchase.
A few technical decisions I made that are worth calling out: - All processing happens on-device using CoreLocation and CoreMotion - No backend, which means no breach surface for your location data - Battery impact is minimal — same approach as iOS's own significant-location-change API, with minimal active location tracking to produce clean polylines - We use SwiftUI for most of the regular layout, but UIKit for the map & bottom sheet for fine control
What I mainly use it for is to know where I've been on my holidays, but it's also cool to see insights on my daily patterns so I just leave it on!
Check out the screenshots on the AppStore! https://replayapp.jaxtam.dev
Hope Replay would be useful for you. I'm open to any feedback. Thanks everyone!
The system maintains probabilistic ratings for each image, modeling both estimated quality (μ) and uncertainty (σ), and updates rankings globally after each comparison. This allows accurate ranking from incomplete and noisy comparison data.
To further accelerate ranking on large datasets, Image Ranker includes several optimization strategies:
Sequential elimination, reducing ranking complexity from O(N²) to O(N) Uncertainty-driven sampling (smart shuffle) to prioritize informative comparisons Auto-shuffling for continuous ranking efficiency The tool provides a lightweight web-based interface that allows users to:
Compare images directly from local directories without uploading data Track and export rankings (CSV) with resume capability Annotate exclusions with structured reasons Attach contextual metadata to images Image Ranker is particularly useful for:
Human preference data collection for reinforcement learning from human feedback (RLHF) Evaluation and selection of generative model outputs (e.g. diffusion models) Dataset curation and ranking under limited labeling budgets By combining probabilistic ranking with efficient comparison strategies, Image Ranker enables scalable preference estimation workflows for modern machine learning and data-centric applications.
Spectator is a powerful and open source DSL made for cybersecurity that makes hard tasks simple.
No need to jump from one tool to another for doing high level tasks. Want to do Recon? Spectator is here. Want to work with OSINT? Spectator is here. Want to automate your tasks? Spectator is here. Want to make GUI, TUI, CLI tools or even extend the language? SPECTATOR IS HERE.
You can work with Speed and ease together in this language. Use it for simulating attacks and also use it for defence.
Example Hello World --> print("Hello World")
Example GUI -->
#Import Spec.GUI
open.window()
end()
Download Spectator from here --> https://spectatorlang.pages.dev/
Want the Source code? --> https://github.com/CzaxStudio/Spectator
Spectator v2 | See Everything. Miss Nothing.
Generate multi-language request/response examples for JSON or YAML API docs, or test cases for interviews from one source.