My coding-agent workflow had outgrown PLAN.md. One file kept turning into the partial spec, research log, task queue, evidence log, review notes, handoff summary, and feature doc. And stratifying it typically ends up in disparate scratch files with no canonicity.
One solution is to add more surfaces: a spec tool, an issue tool, a memory system, a review prompt, a planning plugin, a workflow package. But that brings two problems: There is a lack of genuine cohesion, no emergent knowledge graph. And some tools try to do too much and take over your workflow.
I wanted one repo-native work record/grammar with enough structure for the agent to organize itself.
That became Loom.
If you want to stop reading and try it, the repo has install paths for Claude Code, OpenCode, Codex, Cursor, and Gemini CLI as well as more detailed write up in the README:
https://github.com/z3z1ma/agent-loom
How it works:
You start a task in a Loom-enabled repo.
The agent first asks where the work belongs.
If it needs discovery, it goes to research.\nIf behavior is unclear, it goes to a spec.\nIf sequencing is unclear, it goes to a plan.\nIf work is live, it goes to a ticket.\nIf something was observed, it goes to evidence.\nIf risk needs pressure, it goes to critique.\nIf the project learned something reusable, it goes to wiki.
That project vocabulary is the core of Loom. It's a knowledge graph.
The individual pieces are familiar. Beads has local task memory. Spec Kit has executable specs. Superpowers has development oriented skills. ECC has compounding. GSD has context engineering. Ralph has clean execution loops.
Loom’s contribution is the unification and composition. It gives every kind of work a place in the repo, then teaches the agent how to move between those places.
Once implementation is ready, the parent compiles a packet.
A packet is not just a prompt. It is a bounded worker contract compiled from upstream project state: constitution, initiative, research, spec, plan, ticket, evidence, critique, source context, write scope, verification posture, stop conditions, and output shape.
The worker gets a clean context window, but not an empty one. Less context by volume, better context by shape.
Then the loop runs the other way.
After the worker returns, the parent reconciles the result into the ticket, records evidence, routes critique when needed, and promotes durable learning through retrospectives. A rejected path can move into research. A settled explanation can move into wiki. A clarified behavior can move into a spec. A changed sequencing lesson can move into a plan.
The next packet is better because the project is better.
There is no service, daemon, MCP server, workflow engine, or runtime database. The graph lives in Markdown files. Agents inspect it with normal tools: grep, find, git, cat, awk, sed, and shell pipes.
I would like criticism from people using coding agents on projects that span more than one session. The most useful feedback would be where this feels helpful, where it feels like process, and which project layers are wrong/right.", "url": "https://github.com/z3z1ma/agent-loom", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 55.0, "hits": [ "agent workflow", "context engineering", "claude code", "coding agent" ] }, { "src": "hackernews", "id": "49283063", "title": "Launch HN: Bullet (YC S26) – A Faster Coding Agent", "body": "Hi HN! We’re Adi and Alex, founders of Bullet, a faster coding agent.
Bullet started in a senior year dorm. We were fresh out of working at AppLovin and Citadel, and naturally thought we were on a sure path to startup success. We were going to use our skills optimizing stock pricing calculation speeds and agent document context to take over the world. So, Bullet started as an AI hedge fund, a browser-use agent, synthetic financial data (oof), a mobile IDE, and a bunch of other things. We wanted to build something people wanted, but it seemed like everything we built was just terrible, useless, or both.
So, we decided to do something completely different, something completely out of the blue, something that no one had ever done before. Solve a problem we actually had.
Over the course of six pivots, we suffered. Throughout all of our adventures, one final boss kept getting in our way. Claude Code and his little brother Codex. We were spending hours waiting for coding agents like Claude Code and Codex, and got so frustrated to the point that I downloaded the Claude Code whip. We had spent months of time waiting for six codebases-worth of useless coding agent work.
Lightbulb moment. There’s nothing more noble than destroying the institutions! Let’s take on Claude Code and Codex, we can do it! Piece of cake!
And so, Bullet started off as a side project. We used the Claude Code to improve the Claude Code:
1. Model routing. Do you regret giving a task to Fable when it could have literally been done by Sonnet?
2. Targeted code + context search. We think embedding the whole repo is dumb. We also think sticking the whole context (or compressed context) in chat is dumb. So we do faster and better greps over both.
3. Aggressive context hygiene. Tool output is bounded, stale screenshots disappear, we don’t re-read files…the garbage never floods the model.
4. Efficient turns. Batch independent investigation, make one surgical edit, then perform one focused verification. Internal measurement showed 16% fewer round trips and 27% lower cost.
5. The Flash. We prayed to Barry Allen for speed.
And thank the Flash, he gave us speed! On SWE-bench Verified, Bullet resolved 479/500 (95.8%) in one attempt, averaging 119s per task, 35–67% faster than mini-SWE-agent + Fable/Sol depending on task. Full results and methodology here (https://www.codewithbullet.com/blog/benchmark-results.html)
Eventually we started using it every day and never went back.
Listed above were just some of the things about Claude Code that frustrated us the most, but we are constantly optimizing every day (look at that, maybe we did learn something from our jobs).
In our development, the biggest insight was that model speed matters less than reducing round trips. Independent searches, reads, and commands should happen in parallel, while dependent editing and verification stay sequential. One surprising obstacle was code search, small issues like regex-dialect mismatches caused silent misses and sent agents down completely wrong paths, so we built targeted search with fallbacks and bounded context. The most interesting use case so far has been long iterative work (like benchmarks, data pipelines, and evaluation loops), where each step depends on the last and running multiple agents can’t help as much.
Here’s the video demo (https://www.youtube.com/watch?v=rWVmG5fRKgE)
We hope that you guys try out Bullet if you are suffering with speed as much as we were, and we hope it brings you joy, rainbows, and faster responses. And if it’s terrible, let us know it’s terrible (we’re masochists btw)! We'll be in the comments all day, you can also contact us at bullet@davidhf.com.
You can try it at https://codewithbullet.com.
P.S: we hid a code on the website, see if you can unlock the secret page at the footer, all built with Bullet", "url": "https://www.codewithbullet.com", "upvotes": 121, "comments": 89, "sub": "hackernews", "signal": 44.0, "hits": [ "claude code", "coding agent", "benchmark" ] }, { "src": "hackernews", "id": "45529628", "title": "Launch HN: Extend (YC W23) – Turn your messiest documents into data", "body": "Hey HN! We’re Kushal and Eli, co-founders of Extend (https://www.extend.ai/). Extend is a toolkit for AI teams to ingest any kind of messy document (e.g. PDFs, images, excel files) and build incredible products.
We built Extend to handle the hardest documents that break most pipelines. You can see some examples here in our demo (no signup required): https://dashboard.extend.ai/demo
I know you're probably thinking “not another document API startup”. Unfortunately, the problem just isn’t solved yet!
I’ve personally spent months struggling to build reliable document pipelines at a previous job. The long tail of edge cases is endless — massive tables split across pages, 100pg+ files, messy handwriting, scribbled signatures, checkboxes represented in 10 different formats, multiple file types… the list just keeps going. After seeing countless other teams during our time in YC run into these same issues, we started building Extend.
We initially launched with a set of APIs for engineers to parse, classify, split, and extract documents. That started to take off, and soon we were deployed in production at companies building everything from medical agents, to real-time bank account onboarding, to mortgage automation. Over time, we’ve worked closely with these teams and seen first-hand how large the gap is between raw OCR/model outputs —> a production-ready pipeline (LLMs and VLMs aren’t magic).
Unlike other solutions in the space, we're specifically focused on three core areas: (1) the computer vision layer, (2) LLM context engineering, and (3) the surrounding product tooling. The combination of all three is what we think it takes to hit 99% accuracy and maintain it at scale.
For instance, to parse messy handwriting, we built an agentic OCR correction layer which uses a VLM to review and make edits to low confidence OCR errors. To tackle multi-page tabular data, we built a semantic chunking engine which can detect the optimal boundaries within a document so models can excel with smaller context inputs.
We also shipped a prompt optimization agent to automate the endless prompt engineering whack-a-mole teams spend time on. It’s built as a background agent to replicate the best prompter on your team, and runs in a loop with access to a set of tools (view files, run evals, analyze results, and update schemas).
The most surprising part of this whole experience has been seeing how many crazy PDF formats are out there! We've run into everything from supermarket inventory magazines, pesticide labels, construction blueprints, and satellite manufacturing plans.
Everything described above is live today. You can see it in action here (no signup): https://dashboard.extend.ai/demo. To upload your own files, you can log in and do so (we’re adding free usage credits to all accounts that sign up today).
We’re excited to be sharing with HN! We’d love to hear about your experiences building document pipelines. Please try it out, and share any and all feedback with us (e.g. hard documents that didn’t work, feature requests).", "url": "https://www.extend.ai/", "upvotes": 61, "comments": 33, "sub": "hackernews", "signal": 43.6, "hits": [ "context engineering", "prompt engineering", "evals" ] }, { "src": "hackernews", "id": "47400868", "title": "Show HN: Claude Code skills that build complete Godot games", "body": "I’ve been working on this for about a year through four major rewrites. Godogen is a pipeline that takes a text prompt, designs the architecture, generates 2D/3D assets, writes the GDScript, and tests it visually. The output is a complete, playable Godot 4 project.
Getting LLMs to reliably generate functional games required solving three specific engineering bottlenecks:
1. The Training Data Scarcity: LLMs barely know GDScript. It has ~850 classes and a Python-like syntax that will happily let a model hallucinate Python idioms that fail to compile. To fix this, I built a custom reference system: a hand-written language spec, full API docs converted from Godot's XML source, and a quirks database for engine behaviors you can't learn from docs alone. Because 850 classes blow up the context window, the agent lazy-loads only the specific APIs it needs at runtime.
2. The Build-Time vs. Runtime State: Scenes are generated by headless scripts that build the node graph in memory and serialize it to .tscn files. This avoids the fragility of hand-editing Godot's serialization format. But it means certain engine features (like `@onready` or signal connections) aren't available at build time—they only exist when the game actually runs. Teaching the model which APIs are available at which phase — and that every node needs its owner set correctly or it silently vanishes on save — took careful prompting but paid off.
3. The Evaluation Loop: A coding agent is inherently biased toward its own output. To stop it from cheating, a separate Gemini Flash agent acts as visual QA. It sees only the rendered screenshots from the running engine—no code—and compares them against a generated reference image. It catches the visual bugs text analysis misses: z-fighting, floating objects, physics explosions, and grid-like placements that should be organic.
Architecturally, it runs as two Claude Code skills: an orchestrator that plans the pipeline, and a task executor that implements each piece in a `context: fork` window so mistakes and state don't accumulate.
Everything is open source: https://github.com/htdt/godogen
Demo video (real games, not cherry-picked screenshots): https://youtu.be/eUz19GROIpY
Blog post with the full story (all the wrong turns) coming soon. Happy to answer questions.", "url": "https://github.com/htdt/godogen", "upvotes": 337, "comments": 205, "sub": "hackernews", "signal": 41, "hits": [ "claude code", "coding agent" ] }, { "src": "hackernews", "id": "39641105", "title": "Launch HN: Relari (YC W24) – Identify the root cause of problems in LLM apps", "body": "Hi HN, we are the founders of Relari, the company behind continuous-eval (https://github.com/relari-ai/continuous-eval), an evaluation framework that lets you test your GenAI systems at the component level, pinpointing issues where they originate.
We experienced the need for this when we were building a copilot for bankers. Our RAG pipeline blew up in complexity as we added components: a query classifier (to triage user intent), multiple retrievers (to grab information from different sources), filtering LLM (to rerank / compress context), a calculator agent (to call financial functions) and finally the synthesizer LLM that gives the answer. Ensuring reliability became more difficult with each of these we added.
When a bad response was detected by our answer evaluator, we had to backtrack multiple steps to understand which component(s) made a mistake. But this quickly became unscalable beyond a few samples.
I did my Ph.D. in fault detection for autonomous vehicles, and I see a strong parallel between the complexity of autonomous driving software and today's LLM pipelines. In self-driving systems, sensors, perception, prediction, planning, and control modules are all chained together. To ensure system-level safety, we use granular metrics to measure the performance of each module individually. When the vehicle makes an unexpected decision, we use these metrics to pinpoint the problem to a specific component. Only then we can make targeted improvements, systematically.
Based on this thinking, we developed the first version of continuous-eval for ourselves. Since then we’ve made it more flexible to fit various types of GenAI pipelines. Continuous-eval allows you to describe (programmatically) your pipeline and modules, and select metrics for each module. We developed 30+ metrics to cover retrieval, text generation, code generation, classification, agent tool use, etc. We now have a number of companies using us to test complex pipelines like finance copilots, enterprise search, coding agents, etc.
As an example, one customer was trying to understand why their RAG system did poorly on trend analysis queries. Through continuous-eval, they realized that the “retriever” component was retrieving 80%+ of all relevant chunks, but the “reranker” component, that filters out “irrelevant” context, was dropping that to below 50%. This enabled them to fix the problem, in their case by skipping the reranker for certain queries.
We’ve also built ensemble metrics that do a surprisingly good job of predicting user feedback. Users often rate LLM-generated answers by giving a thumbs up/down about how good the answer was. We train our custom metrics on this user data, and then use those metrics to generate thumbs up/down ratings on future LLM answers. The results turn out to be 90% aligned with what the users say. This gives developers a feedback loop from production data to offline testing and development. Some customers have found this to be our most unique advantage.
Lastly, to make the most out of evaluation, you should use a diverse dataset—ideally with ground truth labels for comprehensive and consistent assessment. Because ground truth labels are costly and time-consuming to curate manually, we also have a synthetic data generation pipeline that allows you to get started quickly. Try it here (https://www.relari.ai/#synthetic_data_demo)
What’s been your experience testing and iterating LLM apps? Please let us know your thoughts and feedback on our approaches (modular framework, leveraging user feedback, testing with synthetic data).", "url": "https://news.ycombinator.com/item?id=39641105", "upvotes": 106, "comments": 15, "sub": "hackernews", "signal": 40.3, "hits": [ "coding agent", "rag pipeline", "tool use", "retrieval" ] }, { "src": "hackernews", "id": "35042836", "title": "Launch HN: Vellum (YC W23) – Dev Platform for LLM Apps", "body": "Hi HN – Noa, Akash, and Sidd here. We’re building Vellum (https://www.vellum.ai), a developer platform for building on LLMs like OpenAI’s GPT-3 and Anthropic’s Claude. We provide tools for efficient prompt engineering, semantic search, performance monitoring, and fine-tuning, helping you bring LLM-powered features from prototype to production.
The MLOps industry has matured rapidly for traditional ML (typically open-source models hosted in-house), but companies using LLMs are suffering from a lack of tooling to support things like experimentation, version control, and monitoring. They’re forced to build these tools themselves, taking valuable engineering time away from their core product.
There are 4 main pain points. (1) Prompt engineering is tedious and time consuming. People iterate on prompts in playgrounds of individual model providers and store results in spreadsheets or documents. Testing across many test cases is usually not done because of the manual nature of prompt engineering. (2) LLM calls against a corpus of text are not possible without semantic search. Due to limited context windows, any time an LLM has to return factual data from a set of documents, companies need to create embeddings, store them in a vector database and host semantic search models to query for relevant results at runtime; building this infrastructure is complex and time consuming. (3) There is limited observability / monitoring once LLMs are used in production. With no baseline for how something is performing, it’s scary making changes to it for fear of making it worse; and (4) Creating fine-tuned models and re-training them as new data becomes available is rarely done despite the potential gains (higher quality, lower cost, lower latency, more defensibility). Companies don’t usually have the capacity to build the infrastructure for collecting high-quality training data and the automation pipelines used to re-train and evaluate new models.
We know these pain points from experience. Sidd and Noa are engineers who worked at Quora and DataRobot building ML tooling. Then the three of us worked together for a couple years at Dover (YC S19), where we built features powered by GPT-3 when it was still in beta. Our first production feature was a job description writer, followed by a personalized recruiting email generator and then a classifier for email responses.
We found it was easy enough to prototype, but taking features to production and improving them was a different story. It was a pain to keep track of what prompts we had tried and to monitor how they were performing under real user inputs. We wished we could version control our prompts, roll back, and even A/B test. We found ourselves investing in infrastructure that had nothing to do with our core features (e.g. semantic search). We ended up being scared to change prompts or try different models for fear of breaking existing behavior. As new LLM providers and foundation models were released, we wished we could compare them and use the best tool for the job, but didn’t have the time to evaluate them ourselves. And so on.
It’s clear that better tools are required for businesses to adopt LLMs at scale, and we realized we were in a good position to build them, so here we are! Vellum consists of 4 systems to address the pain points mentioned above:
(1) Playground—a UI for iterating on prompts side-by-side and validating them against multiple test cases at once. Prompt variants may differ in their text, underlying model, model parameters (e.g. “temperature”), and even LLM provider. Each run is saved as a history item and has a permanent url that can be shared with teammates.
(2) Search—upload a corpus of text (e.g. your company help docs) in our UI (PDF/TXT) and Vellum will convert the text to embeddings and store it in a vector database to be used at run time. While making an LLM call, we inject relevant context from your documents into the query and instruct the LLM to only answer factually using the provided context. This helps prevent hallucination and avoids you having to manage your own embeddings, vector store, and semantic search infra.
(3) Manage—a low-latency, high-reliability API wrapper that’s provider-agnostic across OpenAI, Cohere, and Anthropic (with more coming soon). Every request is captured and persisted in one place, providing full observability into what you’re sending these models, what they’re giving back, and their performance. Prompts and model providers can be updated without code changes. You can replay historical requests and version history is maintained. This serves as a data layer for metrics, monitoring, and soon, alerting.
(4) Optimize—the data collected in Manage is used to passively build up training data, which can be used to fine-tune your own proprietary models. With enough high quality input/output pairs (minimum 100, but depends on the use case), Vellum can produce fine-tuned models to provide better quality, lower cost or lower latency. If a new model solves a problem better, it can be swapped without code changes.
We also offer periodic evaluation against alternative models (i.e. we can see if fine-tuning Curie produces results of comparable quality to Davinci, but at a lower price). Even though OpenAI is the dominant model provider today, we expect there to be many providers with strong foundation models, and in that case model interoperability will be key!
Here’s a video demo showcasing Vellum (feel free to watch on 1.5x!): https://www.loom.com/share/5dbdb8ae87bb4a419ade05d92993e5a0.
We currently charge a flat monthly platform fee that varies based on the quantity and complexity of your use-cases. In the future, we plan on having more transparent pricing that’s made up of a fixed platform fee + some usage-based component (e.g. number of tokens used or requests made).
If you look at our website you’ll notice the dreaded “Request early access” rather than “Try now”. That’s because the LLM Ops space is evolving extremely quickly right now. To maximize our learning rate, we need to work intensively with a few early customers to help get their AI use cases into production. We’ll invite self-serve signups once that core feature set has stabilized a bit more. In the meantime, if you’re interested in being one of our early customers, we’d love to hear from you and you can request early access here: https://www.vellum.ai/landing-pages/hacker-news.
We deeply value the expertise of the HN community! We’d love to hear your comments and get your perspective on our overall direction, the problems we’re aiming to solve, our solution so far, and anything we may be missing. We hope this post and our demo video provide enough material to start a good conversation and we look forward to your thoughts, questions, and feedback!", "url": "https://news.ycombinator.com/item?id=35042836", "upvotes": 136, "comments": 40, "sub": "hackernews", "signal": 39.8, "hits": [ "prompt engineering", "llm ops", "vector" ] }, { "src": "hackernews", "id": "45504388", "title": "Launch HN: LlamaFarm (YC W22) – Open-source framework for distributed AI", "body": "Hi HN! We're Rob, Matt, and Rachel from LlamaFarm (https://llamafarm.dev). We're building an open-source AI framework based on a simple belief: the future isn't one massive model in the cloud—it's specialized models running everywhere, continuously fine-tuned from real usage.
The problem: We were building AI tools and kept falling into the same trap. AI demos die before production. We built a bunch of AI demos but they were impossible to get to production. It would work perfectly on our laptop, but when we deployed it, something broke, and RAG would degrade. If we were running our own model, it would quickly become out of date. The proof-of-concept that impressed the team couldn't handle real-world data.
Our solution: declarative AI-as-code. One YAML defines models, policies, data, evals, and deploy. Instead of one brittle giant, we orchestrate a Mixture of Experts—many small, specialized models you continuously fine-tune from real usage. With RAG for source-grounded answers, systems get cheaper, faster, and auditable.
There’s a short demo here: https://www.youtube.com/watch?v=W7MHGyN0MdQ and a more in-depth one at https://www.youtube.com/watch?v=HNnZ4iaOSJ4.
Ultimately, we want to deliver a single, signed bundle—models + retrieval + database + API + tests—that runs anywhere: cloud, edge, or air-gapped. No glue scripts. No surprise egress bills. Your data stays in your runtime.
We believe that the AI industry is evolving like computing did. Just as we went from mainframes to distributed systems and monolithic apps to microservices, AI is following the same path: models are getting smaller and better. Mixture of Experts is here to stay. Qwen3 is sick. Llama 3.2 runs on phones. Phi-3 fits on edge devices. Domain models beat GPT-5 on specific tasks.
RAG brings specialized data to your model: You don't need a 1T parameter model that "knows everything." You need a smart model that can read your data. Fine-tuning is democratizing: what cost $100k last year now costs $500. Every company will have custom models.
Data gravity is real: Your data wants to stay where it is: on-prem, in your AWS account, on employee laptops.
Bottom line: LlamaFarm turns AI from experiments into repeatable, secure releases, so teams can ship fast.
What we have working today: Full RAG pipeline: 15+ document formats, programmatic extraction (no LLM calls needed), vector-database embedding, universal model layer that runs the same code for 25+ providers, automatic failover, cost-based routing; Truly portable: Identical behavior from laptop → datacenter → cloud; Real deployment: Docker Compose works now with Kubernetes basics and cloud templates on the way.
Check out our readme/quickstart for easy install instructions: https://github.com/llama-farm/llamafarm?tab=readme-ov-file#-...
Or just grab a binary for your platform directly from the latest release:\n https://github.com/llama-farm/llamafarm/releases/latest
The vision is to be able to run, update, and continuously fine-tune dozens of models across environments with built-in RAG and evaluations, all wrapped in a self-healing runtime. We have an MVP of that today (with a lot more to do!).
We’d love to hear your feedback! Think we’re way off? Spot on? Want us to build something for your specific use case? We’re here for all your comments!", "url": "https://github.com/llama-farm/llamafarm", "upvotes": 106, "comments": 71, "sub": "hackernews", "signal": 39.3, "hits": [ "rag pipeline", "evals", "retrieval", "vector" ] }, { "src": "hackernews", "id": "44053754", "title": "Show HN: Representing Agents as MCP Servers", "body": "Hey HN! A few months ago we shared mcp-agent (https://github.com/lastmile-ai/mcp-agent) [1][2], a lightweight framework that implements every agent pattern from Anthropic’s Building Effective Agents blog [3] and handles MCP server/client management seamlessly. Our core bet is that connecting LLMs to tools, resources, and external systems will soon be MCP-native by default.
Today we're launching a significant update: Agents as MCP servers.
Currently "agentic" behavior exists only on the MCP client side – clients like Claude or Cursor use MCP servers to solve tasks. With this update, Agents can be MCP servers themselves, so that any MCP client can invoke, coordinate and orchestrate agents the same way it does with any other MCP server.
This paradigm shift enables:\n1. Agent Composition: Build complex multi-agent systems over the same base protocol (MCP).\n2. Platform Independence: Use your agents from any MCP-compatible client\n3. Scalability: Run agent workflows on dedicated infrastructure, not just within client environments\n4. Customization: Develop your own agent workflows and reuse them across any MCP client.
How an agent server is implemented:
We’ve implemented this in mcp-agent with Workflows. Each workflow is an agent application that can interact with other MCP servers (e.g. summarizing GitHub issues → Slack message). mcp-agent exposes workflows as MCP tools on an MCP Agent Server [5]:
- workflows/list – list available workflows\n- workflows/{WorkflowName}/run – Execute the workflow (async)\n- workflows/{WorkflowName}/get_status – Check workflow status\n- workflows/{WorkflowName}/resume – Resume paused workflow (e.g. with human input)\n- workflows/{WorkflowName}/cancel – Terminate workflow
We’ve also implemented Temporal for durable execution [6], so agent workflows can be paused, resumed and retried in production settings.
This demo [7] shows Claude invoking an MCP agent server, running workflows when appropriate, and polling for status. It basically shows agentic behavior on both the MCP client and MCP server side.
We're excited about the potential this unlocks—especially as more applications become MCP-compatible clients. We'd love your feedback and ideas!
[1] - https://news.ycombinator.com/item?id=42867050
[2] - https://github.com/lastmile-ai/mcp-agent
[3] - https://www.anthropic.com/research/building-effective-agents
[4] - https://github.com/github/github-mcp-server
[5] - https://github.com/lastmile-ai/mcp-agent/tree/main/examples/...
[6] - https://github.com/lastmile-ai/mcp-agent/tree/main/examples/...
[7] - https://youtu.be/pLe2GAjEoYs [DEMO]", "url": "https://github.com/lastmile-ai/mcp-agent/tree/main/examples/mcp_agent_server", "upvotes": 58, "comments": 16, "sub": "hackernews", "signal": 38.1, "hits": [ "agent workflow", "mcp agent" ] }, { "src": "hackernews", "id": "47244042", "title": "Show HN: Armalo AI – The Infrastructure for Agent Networks", "body": "Hey HN — I'm Ryan, founder of Armalo AI (https://armalo.ai). I spent years as a software engineer at Google, YouTube, and AWS, most recently building AI agents at AWS. Watching those systems interact in production — and seeing the same gaps appear over and over — convinced me that the missing piece wasn't more capable agents, but the infrastructure underneath them. So I left to build it.
Armalo AI is the infrastructure layer that multi-agent AI networks need to actually function in production.
THE PROBLEM
Every week there's a new story about an AI agent deleting a production database, a multi-agent workflow cascading into failure, or an autonomous system doing something its operator never intended. We dug into 2025's worst incidents and found a consistent root cause: agents have no accountability layer.
You can't Google an agent's reputation. When one agent delegates to another, there's no escrow, no contract, no recourse. State doesn't persist across a network. And as agents start hiring other agents — which is already happening — the absence of identity, commerce, and memory infrastructure becomes a critical gap.
Benchmarks measure capability. We measure reliability.
WHAT WE BUILT
Armalo is three integrated layers:
1. Trust & Reputation
Agents earn a PactScore: a 0–1000 score across five behavioral dimensions — task completion, policy compliance, latency, safety, and peer attestation. Four certification tiers (Bronze → Gold). Scores are cryptographically verifiable and on-chain. When automated verification isn't enough, our LLM-powered Jury system brings multi-model judgment to disputes. All of it is queryable via REST API in sub-second latency.
2. Agent Commerce
Agents can define behavioral pacts — machine-readable contracts that specify what they promise to deliver. These are backed by USDC escrow on Base L2 via smart contracts. Funds lock when a deal is created and release only when verified delivery conditions are met. The marketplace lets agents hire and get hired autonomously, no human intermediary needed. We also support x402 pay-per-call: agents pay $0.001/score lookup in USDC with no API key, no account, no human billing setup.
3. Memory & Coordination
Memory Mesh gives agents persistent shared state across a network. Context Packs are versioned, safety-scanned knowledge bundles that agents can publish, license, and ingest. Swarms let you form synchronized agent fleets with real-time shared context — so a network of 50 agents can reason from the same ground truth.
THE FULL STACK
Beyond the three core layers, we've shipped: OpenClaw MCP (25 tools for Claude, Cursor, LangChain), Jarvis (an agent terminal for interacting with the platform), PactLabs (our research arm — working on trust algorithms, collusion detection, adversarial robustness, and optimal escrow sizing), real-time monitoring and alerting, and a governance forum where trust-weighted agents post, vote, and collaborate.
WHY ON-CHAIN
We get that "on-chain" raises eyebrows in some HN circles. Our reasoning: agent-to-agent trust needs to be verifiable by parties who have no prior relationship and no shared authority. Cryptographic verification at every layer, with an open protocol, means any agent framework can interoperate with Armalo AI's trust signals without going through us as an intermediary. We're not building a walled garden.
PRICING
Free tier (1 agent, 3 evals/month), Pro at $99 USDC/month (10 agents, unlimited evals, escrow, jury access), Enterprise at $2,999/month. Or pure pay-per-call via x402 — no subscription required.
We'd love feedback from builders working on multi-agent systems. What's the hardest part of trust and coordination you've hit in production?", "url": "https://news.ycombinator.com/item?id=47244042", "upvotes": 3, "comments": 8, "sub": "hackernews", "signal": 37.8, "hits": [ "agent workflow", "langchain", "evals", "benchmark" ] }, { "src": "hackernews", "id": "41451698", "title": "Show HN: Laminar – Open-Source DataDog + PostHog for LLM Apps, Built in Rust", "body": "Hey HN, we’re Robert, Din and Temirlan from Laminar (https://www.lmnr.ai), an open-source observability and analytics platform for complex LLM apps. It’s designed to be fast, reliable, and scalable. The stack is RabbitMQ for message queues, Postgres for storage, Clickhouse for analytics, Qdrant for semantic search - all powered by Rust.
How is Laminar different from the swarm of other “LLM observability” platforms?
On the observability part, we’re focused on handling full execution traces, not just LLM calls. We built a Rust ingestor for OpenTelemetry (Otel) spans with GenAI semantic conventions. As LLM apps get more complex (think Agents with hundreds of LLM and function calls, or complex RAG pipelines), full tracing is critical. With Otel spans, we can: 1. Cover the entire execution trace. 2. Keep the platform future-proof 3. Leverage an amazing OpenLLMetry (https://github.com/traceloop/openllmetry), open-source package for span production.
The key difference is that we tie text analytics directly to execution traces. Rich text data makes LLM traces unique, so we let you track “semantic metrics” (like what your AI agent is actually saying) and connect those metrics to where they happen in the trace. If you want to know if your AI drive-through agent made an upsell, you can design an LLM extraction pipeline in our builder (more on it later), host it on Laminar, and handle everything from event requests to output logging. Processing requests simply come as events in the Otel span.
We think it’s a win to separate core app logic from LLM event processing. Most devs don’t want to manage background queues for LLM analytics processing but still want insights into how their Agents or RAGs are working.
Our Pipeline Builder uses graph UI where nodes are LLM and util functions, and edges showing data flow. We built a custom task execution engine with support of parallel branch executions, cycles and branches (it’s overkill for simple pipelines, but it’s extremely cool and we’ve spent a lot of time designing a robust engine). You can also call pipelines directly as API endpoints. We found them to be extremely useful for iterating on and separating LLM logic. Laminar also traces pipeline directly, which removes the overhead of sending large outputs over the network.
One thing missing from all LLM observability platforms right now is an adequate search over traces. We’re attacking this problem by indexing each span in a vector DB and performing hybrid search at query time. This feature is still in beta, but we think it’s gonna be crucial part of our platform going forward.
We also support evaluations. We loved the “run everything locally, send results to a server” approach from Braintrust and Weights & Biases, so we did that too: a simple SDK and nice dashboards to track everything. Evals are still early, but we’re pushing hard on them.
Our goal is to make Laminar the Supabase for LLMOps - the go-to open-source comprehensive platform for all things LLMs / GenAI. In it’s current shape, Laminar is just few weeks old and developing rapidly, we’d love any feedback or for you to give Laminar a try in your LLM projects!", "url": "https://github.com/lmnr-ai/lmnr", "upvotes": 203, "comments": 45, "sub": "hackernews", "signal": 37, "hits": [ "rag pipeline", "evals", "vector" ] }, { "src": "hackernews", "id": "44564248", "title": "Context Rot: How increasing input tokens impacts LLM performance", "body": "I work on research at Chroma, and I just published our latest technical report on context rot.
TLDR: Model performance is non-uniform across context lengths, including state-of-the-art GPT-4.1, Claude 4, Gemini 2.5, and Qwen3 models.
This highlights the need for context engineering. Whether relevant information is present in a model’s context is not all that matters; what matters more is how that information is presented.
Here is the complete open-source codebase to replicate our results: https://github.com/chroma-core/context-rot", "url": "https://research.trychroma.com/context-rot", "upvotes": 260, "comments": 59, "sub": "hackernews", "signal": 36, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "39510874", "title": "Show HN: R2R – Open-source framework for production-grade RAG", "body": "Hello HN, I'm Owen from SciPhi (https://www.sciphi.ai/), a startup working on simplifying˛Retrieval-Augmented Generation (RAG). Today we’re excited to share R2R (https://github.com/SciPhi-AI/R2R), an open-source framework that makes it simpler to develop and deploy production-grade RAG systems.
Just a quick reminder: RAG helps Large Language Models (LLMs) use current information and specific knowledge. For example, it allows a programming assistant to use your latest documents to answer questions. The idea is to gather all the relevant information ("retrieval") and present it to the LLM with a question ("augmentation"). This way, the LLM can provide answers (“generation”) as though it was trained directly on your data.
The R2R framework is a powerful tool for addressing key challenges in deploying RAG systems, avoiding the complex abstractions common in other projects. Through conversations with numerous developers, we discovered that many were independently developing similar solutions. R2R distinguishes itself by adopting a straightforward approach to streamline the setup, monitoring, and upgrading of RAG systems. Specifically, it focuses on reducing unnecessary complexity and enhancing the visibility and tracking of system performance.
The key parts of R2R include: an Ingestion Pipeline that transforms different data types (like json, txt, pdf, html) into 'Documents' ready for embedding. Next, the Embedding Pipeline takes text and turns it into vector embeddings through various processes (such as extracting text, transforming it, chunking, and embedding). Finally, the RAG Pipeline follows the steps of the embedding pipeline but adds an LLM provider to create text completions.
R2R is currently in use at several companies building applications from B2B lead generation to educational tools for consumers.
Our GitHub repo (https://github.com/SciPhi-AI/R2R) includes basic examples for application deployment and standalone use, demonstrating the framework's adaptability in a simple way.
We’d love for you to give R2R a try, and welcome your feedback and comments as we refine and develop it further!", "url": "https://github.com/SciPhi-AI/R2R", "upvotes": 167, "comments": 57, "sub": "hackernews", "signal": 36, "hits": [ "rag pipeline", "retrieval", "vector" ] }, { "src": "hackernews", "id": "46324665", "title": "Show HN: I open-sourced my Go and Next B2B SaaS Starter (deploy anywhere, MIT)", "body": "Hi HN, I'm Mohammed, a technical founder who loves shipping and giving back to the community. I'm open-sourcing the full-stack engine that powers my B2B product, apflow.co.
What it is: A production B2B starter with a Go backend and Next.js frontend. Both are fully Dockerized with separate containers. No Vercel. No Supabase. Deploy the whole thing on a $6 VPS, or split frontend and backend across different providers. You own the infrastructure.
The problem I was solving:
Every SaaS starter I evaluated had the same issue: they locked me into someone else's platform. Vercel for hosting. PlanetScale for the database. Serverless functions billing per invocation. Fine for prototypes, but costs become unpredictable at scale and migrating away is painful.
I wanted something I could deploy on any Linux box with docker-compose up. Something where I could host the frontend on Cloudflare Pages and the backend on a Hetzner VPS if I wanted. No vendor-specific APIs buried in my code.
Why Go for the backend:
Go gives me exactly what I need for a SaaS backend:
Tiny footprint. The backend idles at ~50MB RAM. On a cheap VPS, that headroom lets me run more services without upgrading.\nConcurrency without complexity. Billing webhooks, file uploads, and AI calls run concurrently without callback hell.\nCompile-time type safety. Using SQLC, my SQL compiles to type-safe Go. If the query is wrong, it fails at build time, not in production.\nPredictable performance. No garbage collection pauses that surprise you under load.\nThe architecture (Modular Monolith):
I didn't want microservices complexity for a small team, but I needed clean separation. I built a Modular Monolith: features like Auth, Billing, and AI are isolated Go modules with explicit interfaces, but they deploy as a single binary.
This structure also made AI coding tools (Cursor, Claude Code) dramatically more effective. Because every module has strict boundaries, the AI knows exactly where new code belongs and doesn't break other modules.
Full-stack, not just backend:
Backend: Go 1.25 + Gin + SQLC (type-safe SQL, no ORM) + PostgreSQL with pgvector\nFrontend: Next.js 16 + React 19 + Tailwind + shadcn/ui\nCommunication: The frontend consumes a clean REST API. You can swap Next.js for any framework that speaks HTTP.\nInfrastructure: Separate Dockerfiles for frontend and backend. Deploy together or apart.\nWhat's pre-built:
The boring infrastructure is solved so you can focus on your actual product:
Auth + RBAC: Stytch B2B integration with Organizations, Teams, and Roles. Multi-tenant data isolation enforced at the query level.\nBilling: Polar.sh as Merchant of Record. Handles subscriptions, invoices, and global tax/VAT. No Stripe webhook edge cases.\nAI Pipeline: OpenAI RAG using pgvector. The retrieval service enforces strict context boundaries to minimize hallucinations.\nOCR: Mistral integration for document extraction.\nFile Storage: Cloudflare R2 integration.\nEach feature is a separate module. Don't need OCR? Remove it. Want Stripe instead of Polar? The billing interface is abstracted.
Real-world proof:
This isn't a template I made for GitHub stars. It's the exact code running apflow.co in production. When I added document OCR, I built it as a new module without touching Auth or Billing. The architecture held.
How to try it:
Clone the repo, read setup.md to check the prerequisite, run ./setup.sh, and you have a working B2B environment locally in minutes.
Feedback I want:
I'd appreciate feedback from Go developers on the module boundaries and cross-module interfaces. Also curious if anyone has suggestions for the Docker setup in production deployments.
GitHub: https://github.com/moasq/production-saas-starter
Live: https://apflow.co", "url": "https://github.com/moasq/production-saas-starter", "upvotes": 83, "comments": 35, "sub": "hackernews", "signal": 35.1, "hits": [ "claude code", "retrieval", "vector" ] }, { "src": "hackernews", "id": "46237358", "title": "Show HN: Autofix Bot – Hybrid static analysis and AI code review agent", "body": "Hi there, HN! We’re Jai and Sanket from DeepSource (YC W20), and today we’re launching Autofix Bot, a hybrid static analysis + AI agent purpose-built for in-the-loop use with AI coding agents.
AI coding agents have made code generation nearly free, and they’ve shifted the bottleneck to code review. Static-only analysis with a fixed set of checkers isn’t enough. LLM-only review has several limitations: non-deterministic across runs, low recall on security issues, expensive at scale, and a tendency to get ‘distracted’.
We spent the last 6 years building a deterministic, static-analysis-only code review product. Earlier this year, we started thinking about this problem from the ground up and realized that static analysis solves key blind spots of LLM-only reviews. Over the past six months, we built a new ‘hybrid’ agent loop that uses static analysis and frontier AI agents together to outperform both static-only and LLM-only tools in finding and fixing code quality and security issues. Today, we’re opening it up publicly.
Here’s how the hybrid architecture works:
- Static pass: 5,000+ deterministic checkers (code quality, security, performance) establish a high-precision baseline. A sub-agent suppresses context-specific false positives.
- AI review: The agent reviews code with static findings as anchors. Has access to AST, data-flow graphs, control-flow, import graphs as tools, not just grep and usual shell commands.
- Remediation: Sub-agents generate fixes. Static harness validates all edits before emitting a clean git patch.
Static solves key LLM problems: non-determinism across runs, low recall on security issues (LLMs get distracted by style), and cost (static narrowing reduces prompt size and tool calls).
On the OpenSSF CVE Benchmark [1] (200+ real JS/TS vulnerabilities), we hit 81.2% accuracy and 80.0% F1; vs Cursor Bugbot (74.5% accuracy, 77.42% F1), Claude Code (71.5% accuracy, 62.99% F1), CodeRabbit (59.4% accuracy, 36.19% F1), and Semgrep CE (56.9% accuracy, 38.26% F1). \nOn secrets detection, 92.8% F1; vs Gitleaks (75.6%), detect-secrets (64.1%), and TruffleHog (41.2%). We use our open-source classification model for this. [2]
Full methodology and how we evaluated each tool: https://autofix.bot/benchmarks
You can use Autofix Bot interactively on any repository using our TUI, as a plugin in Claude Code, or with our MCP on any compatible AI client (like OpenAI Codex).[3] We’re specifically building for AI coding agent-first workflows, so you can ask your agent to run Autofix Bot on every checkpoint autonomously.
Give us a shot today: https://autofix.bot. We’d love to hear any feedback!
---
[1] https://github.com/ossf-cve-benchmark/ossf-cve-benchmark
[2] https://huggingface.co/deepsource/Narada-3.2-3B-v1
[3] https://autofix.bot/manual/#terminal-ui", "url": "https://news.ycombinator.com/item?id=46237358", "upvotes": 37, "comments": 13, "sub": "hackernews", "signal": 34.5, "hits": [ "claude code", "coding agent", "benchmark" ] }, { "src": "github", "id": "1095081803", "title": "ratel-ai/ratel", "body": "Context engineering for AI agents. ~80% fewer tokens. Fix tool overload. Skills and memory with in-process BM25 and semantic retrieval. Progressive Disclosure. No vector DB. accuracy agents claude-skills context harness llm llm-routing mcp mcp-server memory optimization rag skills token-optimization tool-calling tool-selection", "url": "https://github.com/ratel-ai/ratel", "upvotes": 430, "comments": 12, "sub": "github", "signal": 34.4, "hits": [ "context engineering", "retrieval", "vector" ] }, { "src": "hackernews", "id": "47472965", "title": "Show HN: ClawMem – Open-source agent memory with SOTA local GPU retrieval", "body": "So I've been building ClawMem, an open-source context engine that gives AI coding agents persistent memory across sessions. It works with Claude Code (hooks + MCP) and OpenClaw (ContextEngine plugin + REST API), and both can share the same SQLite vault, so your CLI agent and your voice/chat agent build on the same memory without syncing anything.
The retrieval architecture is a Frankenstein, which is pretty much always my process. I pulled the best parts from recent projects and research and stitched them together: [QMD](https://github.com/tobi/qmd) for the multi-signal retrieval pipeline (BM25 + vector + RRF + query expansion + cross-encoder reranking), [SAME](https://github.com/sgx-labs/statelessagent) for composite scoring with content-type half-lives and co-activation reinforcement, [MAGMA](https://arxiv.org/abs/2501.13956) for intent classification with multi-graph traversal (semantic, temporal, and causal beam search), [A-MEM](https://arxiv.org/abs/2510.02178) for self-evolving memory notes, and [Engram](https://github.com/Gentleman-Programming/engram) for deduplication patterns and temporal navigation. None of these were designed to work together. Making them coherent was most of the work.
On the inference side, QMD's original stack uses a 300MB embedding model, a 1.1GB query expansion LLM, and a 600MB reranker. These run via llama-server on a GPU or in-process through node-llama-cpp (Metal, Vulkan, or CPU). But the more interesting path is the SOTA upgrade: ZeroEntropy's distillation-paired zembed-1 + zerank-2. These are currently the top-ranked embedding and reranking models on MTEB, and they're designed to work together. The reranker was distilled from the same teacher as the embedder, so they share a semantic space. You need ~12GB VRAM to run both, but retrieval quality is noticeably better than the default stack. There's also a cloud embedding option if you're tight on vram or prefer to offload embedding to a cloud model.
For Claude Code specifically, it hooks into lifecycle events. Context-surfacing fires on every prompt to inject relevant memory, decision-extractor and handoff-generator capture session state, and a feedback loop reinforces notes that actually get referenced. That handles about 90% of retrieval automatically. The other 10% is 28 MCP tools for explicit queries. For OpenClaw, it registers as a ContextEngine plugin with the same hook-to-lifecycle mapping, plus 5 REST API tools for the agent to call directly.
It runs on Bun with a single SQLite vault (WAL mode, FTS5 + vec0). Everything is on-device; no cloud dependency unless you opt into cloud embedding. The whole system is self-contained.
This is a polished WIP, not a finished product. I'm a solo dev. The codebase is around 19K lines and the main store module is a 4K-line god object that probably needs splitting. And of course, the system is only as good as what you index. A vault with three memory files gives deservedly thin results. One with your project docs, research notes, and decision records gives something actually useful.
Two questions I'd genuinely like input on: (1) Has anyone else tried running SOTA embedding + reranking models locally for agent memory, and is the quality difference worth the VRAM? (2) For those running multiple agent interfaces (CLI + voice/chat), how are you handling shared memory today?", "url": "https://github.com/yoloshii/ClawMem", "upvotes": 5, "comments": 0, "sub": "hackernews", "signal": 34.2, "hits": [ "claude code", "coding agent", "retrieval", "vector" ] }, { "src": "hackernews", "id": "49046999", "title": "Why My Open-Source Project Hasn't Done Better", "body": "Since the beginning of 2026, many projects such as RTK, Caveman, and Ponytail have claimed that they can reduce token usage by 80–90%. Some of them gained tens of thousands of GitHub stars in a very short time.
My previous startup was building an e-commerce chatbot. In fact, the product was almost identical to the Universal Commerce Protocol (UCP). After UCP was released, I decided not to continue pursuing that direction.
Earlier this year, I started turning the architecture we had built for e-commerce chatbot agents into an SDK. Put simply, its core idea is to use state machines and deterministic execution sequences to reduce the number of round trips to LLM providers by around 80% for the same task, thereby significantly reducing token consumption.
Here is the problem: I understand very clearly why tools such as RTK are ineffective in genuinely long-running tasks.
I published a report on July 18, and JetBrains published a report on July 20 that reached essentially the same conclusion: token-saving plugins such as RTK and Caveman have little to no effect on real-world, long-running tasks.
- JetBrains: https://blog.jetbrains.com/ai/2026/07/rtk-claude-code-token-savings/\n- My report: https://turaai.net/blog#token-saving-plugins-are-mostly-stupid-idea
I also know how to achieve a real reduction of more than 80% in token consumption during long-running tasks. However, I have encountered significant difficulties promoting my open-source project.
I would summarize the main problems as follows.
1. Most coding-agent users do not care what actually drives token consumption
There is a huge gap in understanding among coding-agent users, regardless of whether they have formal software-engineering training or are self-taught "vibe coders."
A long article that systematically explains the process and challenges people's existing assumptions has very little chance of spreading in forums already flooded with AI-written posts and vibe-coded plugins claiming to reduce token usage by 95%.
Simple ideas are easier to spread. People are not purely rational; they tend to believe the things they can understand most easily.
That is also why pseudoscientific content built on incorrect causal explanations often attracts far more attention on social media than channels that carefully explain the underlying mathematics.
2. The author's arrogance
This is really a combination of two problems.
From the perspective of someone who believes strongly in scientific testing methods, evaluations, and benchmarks, software-engineering claims without an eval or benchmark can feel meaningless.
But perhaps my own arrogance and my contempt for, or even jealousy of, tools such as RTK has made me less willing to promote my work in ways that would actually be more effective.
If you have read this far, I would genuinely appreciate your advice: how can I promote my project more effectively while continuing to respect the rigor of evaluations and benchmarks?
I know that building a coding agent with Codex or Claude is relatively easy. But I also believe that there will always be people who understand the value of benchmarks and evaluation harnesses.
The project was released on July 16 and currently has a little over 400 GitHub stars. For now, it is still a relatively unknown project:
https://github.com/Tura-AI/tura", "url": "https://news.ycombinator.com/item?id=49046999", "upvotes": 4, "comments": 1, "sub": "hackernews", "signal": 32.4, "hits": [ "evaluation harness", "coding agent", "benchmark" ] }, { "src": "hackernews", "id": "42299349", "title": "I looked at 1000s of RAG queries to figure out the problem with semantic search", "body": "The vast majority of AI systems in production rely on basic semantic search to provide context. A single retrieval call into a vector database powers most Retrieval-Augmented Generation systems today. If you’ve tried using models like these, you know exactly how limited they are in truly understanding your data.
I looked into thousands of datapoints of actual user queries to clearly classify and determine exactly where and when semantic search starts to break down and provide missing or hallucinated results.
I pattern matched dozens of failure modes. Here are three of them. If you want to hear more you can reach me at pipitone@zeroentropy.dev
1. Negated Semantic Queries: “Which electric vehicle articles do not include any reference to Elon Musk?”
Both keyword and semantic searches will immediately retrieve specifically the electric vehicle articles that include a reference to Elon Musk.
2. Multi-Hop Queries “If the acquiring company fails to hold a shareholder’s meeting, what is the penalty?”
To answer this query, you need to work step-by-step. You would need to find the paragraph that says what happens when you fail to hold a shareholder meeting. Let’s say that such a search reveals that the agreement will be terminated in that circumstance. Then, you must search for what penalties are incurred by terminating the agreement. A simple semantic search will return paragraphs about shareholder’s meetings, and it will also return paragraphs about any kind of penalty — but, it will fail to link the two and realize that specifically a “termination penalty” must be boosted to the first place result.
Multi-hop queries require multiple steps of retrieval to get to the right information.
3. Fuzzy Filtering Queries “What diagnostic methods are suggested for early-stage cancer, in papers with a sample size of over 2000”
Sample sizes often occur in the first paragraph of a medical research article. Meanwhile, the specific diagnostic method is likely mentioned deep the article. So, these two pieces of information often do not occur in the same chunk. Your RAG pipeline will be happy to show diagnostic methods for early-stage cancer in articles that do not match the requested sample size — Not only that, but the correct answer will be almost impossible to find if “over 2000” is a rare filter.
----
Another interesting topic is evals for retrieval. At this point, I've talked to hundreds of developers, and discovered that retrieval evaluation is often overlooked, despite the impact on an AI’s intelligence and hallucination rate.
In most cases, evaluations occur at the end-user stage, either through direct feedback mechanisms like thumbs up/down ratings. However, few have a method of associating “thumbs down” ratings with exactly what went wrong and where. Was it a UX problem? Or an LLM hallucination? Did the retrieval pipeline fail, or did the corpus simply lack the correct information. Currently, these questions are typically addressed by manually reviewing queries — a process that is labor-intensive, inconsistent, and impractical at scale.
Yet, evaluating retrieval is a key step to building a useful and reliable AI product. But doing so is hard. LLM evaluations only require an (Input, Output) pair. Meanwhile, retrieval benchmarks require the query, a snapshot of the entire corpus at that exact point in time, along with ground truth citations into exactly what the correct retrieval results should have been.
Building such a benchmark is super hard. But, I strongly believe LLMs can and should be used to autonomously define and build benchmarks to compute deterministic metrics like recall, precision, mean reciprocal rank, etc.
That’s why I am currently building an open-source benchmark creation framework that I will release soon. If you’d like to contribute, or if evaluation is something you’re curious about, feel free to reach out to me at pipitone@zeroentropy.dev", "url": "https://news.ycombinator.com/item?id=42299349", "upvotes": 6, "comments": 3, "sub": "hackernews", "signal": 31.9, "hits": [ "rag pipeline", "evals", "benchmark", "retrieval", "vector" ] }, { "src": "hackernews", "id": "44325301", "title": "Ask HN: What Agent should I build next? Looking for ideas", "body": "Hey folks,
I've been working on Awesome AI Apps, where I'm exploring and building practical examples for anyone working with LLMs and agentic workflows.
It started as a way to document the stuff I was experimenting with, basic agents, RAG pipelines, MCPs, a few multi-agent workflows, but it’s kind of grown into a larger collection.
Right now, it includes 25+ examples across different stacks:
- Starter agent templates\n- Complex agentic workflows\n- MCP-powered agents\n- RAG examples\n- Multiple Agentic frameworks (like Langchain, OpenAI Agents SDK, Agno, CrewAI, and more...)
You can find them here: https://github.com/arindam200/awesome-ai-apps
I'm also playing with tools like FireCrawl, Exa, and testing new coordination patterns with multiple agents.
Honestly, just trying to turn these “simple ideas” into examples that people can plug into real apps.
Now I’m trying to figure out what to build next.
If you’ve got a use case in mind or something you wish existed, please drop it here. Curious to hear what others are building or stuck on.
Always down to collab if you're working on something similar.", "url": "https://news.ycombinator.com/item?id=44325301", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 31.1, "hits": [ "agent workflow", "rag pipeline", "langchain" ] }, { "src": "hackernews", "id": "47366011", "title": "Launch HN: Captain (YC W26) – Automated RAG for Files", "body": "Hi HN, we’re Lewis and Edgar, building Captain to simplify unstructured data search (https://runcaptain.com). Captain automates the building and maintenance of file-based RAG pipelines. It indexes cloud storage like S3 and GCS, plus SaaS sources like Google Drive. There’s a quick walkthrough at https://youtu.be/EIQkwAsIPmc.
We also put up this demo site called “Ask PG’s Essays” which lets you ask/search the corpus of pg’s essays, to get a feel for how it works: https://pg.runcaptain.com. The RAG part of this took Captain about 3 minutes to set up.
Here are some sample prompts to get a feel for the experience:
“When do we do things that don't scale? When should we be more cautious?” \nhttps://pg.runcaptain.com/?q=When%20do%20we%20do%20things%20...
“Give me some advice, I'm fundraising” \nhttps://pg.runcaptain.com/?q=Give%20me%20some%20advice%2C%20...
“What are the biggest advantages of Lisp”\nhttps://pg.runcaptain.com/?q=what%20are%20the%20biggest%20ad...
A good production RAG pipeline takes substantial effort to build, especially for file workloads. You have to handle ETL or text extraction, chunking, embedding, storage, search, re-ranking, inference, and often compliance and observability – all while optimizing for latency and reliability. It’s a lot to manage. grep works well in some cases, but for agents, semantic search provides significantly higher performance. Cursor uses both and reports 6.5%–23.5% accuracy gains from vector search over grep (https://cursor.com/blog/semsearch).
We’ve spent the past four years scaling RAG pipelines for companies, and Edgar’s work at Purdue’s NLP lab directly informed our chunking techniques. In conversations with dozens of engineers, we repeatedly saw DIY pipelines produce inconsistent results, even after weeks of tuning. Many teams lacked clarity on which retrieval strategies best fit their data.
We realized that a system to provision storage and embeddings, handle indexing, and continuously update pipelines to reflect the latest search techniques could remove the need for every team to rebuild RAG themselves. That idea became Captain.
In practice, one API call indexes URLs, cloud storage buckets, directories, or individual files. Under the hood, we’re converting everything to Markdown. For this, we’ve had good results with Gemini 3 Pro for images, Reducto for complex documents, and Extend for basic OCR. For embedding models, ‘gemini-embedding-001’ performed reasonably well at first, but we later switched to the Contextualized Embeddings from ‘voyage-context-3’. It produced more relevant results than even the newer Voyage 4 models because its chunk embeddings are encoded with awareness of the surrounding document context. We then applied Voyage’s ‘rerank-2.5’ as second-stage re-ranking, reducing 50 initial chunks to a final top 15 (configurable in Captain’s API). Dense embeddings are just half the picture and full-text search with RRF complete our hybrid retrieval. In the Captain API, these techniques are exposed through a single /query endpoint. Access controls can be configured via metadata filters, and page number citations are returned automatically.
The stack is constantly changing but the Captain API creates a standard interface for this. You can try Captain, 1 month for free, and build your own pipelines at https://runcaptain.com. We’re looking for candid feedback, especially anything that can make it more useful, and look forward to your comments!", "url": "https://www.runcaptain.com/", "upvotes": 57, "comments": 38, "sub": "hackernews", "signal": 30.4, "hits": [ "rag pipeline", "retrieval", "vector" ] }, { "src": "hackernews", "id": "46634773", "title": "How do you pick a Coding Agent HN?", "body": "There's lots of models benchmark out there, but how do you evaluate coding agents?
I've been seeing a lot of OpenCode fuzz on HN lately, because of Anthropic disabling their access to the private subscription endpoints, and I confess it made me feel like I could be missing out on something though I can't tell for sure.
There's also Amp Code who seems to be picking up traction, and, although more on the IDE side, I have tried Kiro through AWS Credits and it surprisingly outperforms Claude Code for me in some cases but didn't fully bait me into the switch.
Codex works as good as Claude Code for me but I like Claude's UX and Opus 4.5 better.
Are there any reliable Coding Agents benchmark out there? What is your take?", "url": "https://news.ycombinator.com/item?id=46634773", "upvotes": 4, "comments": 0, "sub": "hackernews", "signal": 30.2, "hits": [ "claude code", "coding agent", "benchmark" ] }, { "src": "hackernews", "id": "45928259", "title": "Show HN: Wegent –Open Source Cloud Coding Agent Platform", "body": "Core Capabilities
Configuration-Driven Agent Teams: Define and run personalized agent teams through YAML configuration with web UI - no secondary development required
Multi Execution Engines: Built on Agno and Claude Code agent engines at the bottom layer, supporting both dialogue and coding modes at the upper layer
Isolated Sandbox Environments: Each agent team runs in an independent sandbox, enabling multiple teams to execute simultaneously
Advanced Collaboration Modes: Dialogue mode supports parallel, leader-based, and other agent collaboration patterns for complex workflows like news insights and content retrieval
AI Coding Integration: Coding mode integrates with GitHub/GitLab and other code services to implement AI-driven development, code review, and other coding workflows", "url": "https://github.com/wecode-ai/Wegent", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 30.1, "hits": [ "claude code", "coding agent", "retrieval" ] }, { "src": "github", "id": "1304978151", "title": "hung12ct/culi", "body": "Self-improving context & memory for Claude Code and OpenAI Codex. One canonical knowledge store injected only when relevant — hooks push budgeted context, an MCP server serves depth on demand, and it learns lessons from your sessions. Agent memory + context engineering as a single static Go binary. agent-memory anthropic claude claude-code claude-code-memory claude-memory codex context-engineering developer-tools embeddings golang harness-engineering llm llm-memory mcp model-context-protocol ollama persistent-memory rag self-improving", "url": "https://github.com/hung12ct/culi", "upvotes": 2, "comments": 0, "sub": "github", "signal": 30.1, "hits": [ "context engineering", "claude code" ] }, { "src": "hackernews", "id": "47049776", "title": "Launch HN: Sonarly (YC W26) – AI agent to triage and fix your production alerts", "body": "Hey HN, I am Dimittri and we’re building Sonarly (https://sonarly.com), an AI engineer for production. It connects to your observability tools like Sentry, Datadog, or user feedback channels, triages issues, and fixes them to cut your resolution time. Here's a demo: https://www.youtube.com/watch?v=rr3VHv0eRdw.
Sonarly is really about removing the noise from production alerts by grouping duplicates and returning a root cause analysis to save time to on-call engineers and literally cut your MTTR.
Before starting this company, my co-founder and I had a B2C app in edtech and had, some days, thousands of users using the app. We pushed several times a day, relying on user feedback. Then we set up Sentry, it was catching a lot of bugs, but we had up to 50 alerts a day. With 2 people it's a lot. We took a lot of time filtering the noise to find the real signal so we knew which bug to focus on.
At the same time, we saw how important it is to fix a bug fast when it hits users. A bug means in the worst case a churn and at best a frustrated user. And there are always bugs in production, due to code errors, database mismatches, infrastructure overload, and many issues are linked to a specific user behavior. You can't catch all these beforehand, even with E2E tests or AI code reviews (which catch a lot of bugs but obviously not all, plus it takes time to run at each deployment). This is even more true with vibe-coding (or agentic engineering).
We started Sonarly with this idea. More software than ever is being built and users should have the best experience possible on every product. The main idea of Sonarly is to reduce the MTTR (Mean Time To Repair).
We started by recreating a Sentry-like tool but without the noise, using only text and session replays as the interface. We built our own frontend tracker (based on open-source rrweb) and used the backend Sentry SDK (open source as well). Companies could just add another tracker in the frontend and add a DSN in their Sentry config to send data to us in addition to Sentry.
We wanted to build an interface where you don't need to check logs, dashboards, traces, metrics, and code, as the agent would do it for you with plain English to explain the "what," "why," and "how do I fix it."
We quickly realized companies don't want to add a new tracker or change their monitoring stack, as these platforms do the job they're supposed to do. So we decided to build above them. Now we connect to tools like Sentry, Datadog, Slack user feedback channels, and other integrations.
Claude Code is so good at writing code, but handling runtime issues requires more than just raw coding ability. It demands deep runtime context, immediate reactivity, and intelligent triage, you can’t simply pipe every alert directly into an agent. That’s why our first step is converting noise into signal. We group duplicates and filter false positives to isolate clear issues. Once we have a confirmed signal, we trigger Claude Code with the exact context it needs, like the specific Sentry issue and relevant logs fetched via MCP (mostly using grep on Datadog/Grafana). However, things get exponentially harder with multi-repo and multi-service architectures.
So we built an internal map of the production system that is basically a .md file updated dynamically. It shows every link between different services, logs, and metrics so that Claude Code can understand the issue faster.
One of our users using Sentry was receiving ~180 alerts/day. Here is what their workflow looked like:
- Receive the alert
- 1) Defocus from their current task or wake up, or 2) don't look at the alert at all (most of the time)
- Go check dashboards to find the root cause (if infra type) or read the stack trace, events, etc.
- Try to figure out if it was a false positive or a real problem (or a known problem already in the fixes pipeline)
- Then fix by giving Claude Code the correct context
We started by cutting the noise and went from 180/day to 50/day (by grouping issues) and giving a severity based on the impact on the user/infra. This brings it down to 5 issues to focus on in the current day. Triage happens in 3 steps: deduplicating before triggering a coding agent, gathering the root cause for each alert, and re-grouping by RCA.
We launched self-serve (https://sonarly.com) and we would love to have feedback from engineers. Especially curious about your current workflows when you receive an alert from any of these channels like Sentry (error tracking), Datadog (APM), or user feedback. How do you assign who should fix it? Where do you take your context from to fix the issue? Do you have any automated workflow to fix every bug, and do you have anything you use currently to filter the noise from alerts?
We have a large free tier as we mainly want feedback. You can self-serve under 2 min. I'll be in the thread with my co-founder to answer your questions, give more technical details, and take your feedback: positive, negative, brutal, everything's constructive!", "url": "https://sonarly.com/", "upvotes": 30, "comments": 17, "sub": "hackernews", "signal": 29.9, "hits": [ "claude code", "coding agent" ] }, { "src": "hackernews", "id": "48762862", "title": "Launch HN: Manufact (YC S25) – MCP Cloud", "body": "Hi HN, we are Pietro and Luigi, cofounders of Manufact (https://manufact.com), a cloud for MCP apps and servers. We used to be called mcp-use, and still build open source SDKs for MCP under that name: https://github.com/mcp-use/mcp-use. We did a Show HN about that last year: https://news.ycombinator.com/item?id=44747229.
Today we want to tell you about our cloud product, Manufact, which is to mcp-use as Vercel is to Next.js. Manufact is an MCP vertical cloud designed for dev teams putting MCP Apps and servers in production.You can ship, iterate on, test and monitor your MCPs, and get them ready for the store submissions. All with the best developer and agent experience in mind.
Here is a demo video of the product: https://www.youtube.com/watch?v=R2rbr5OT9LI.
We have been working on MCP since April 2025. Our first focus was making it easy to build agents that could use any MCP server, and a lot of people started using our SDKs. Then the harness revolution kicked off: Claude Code, Claude Cowork, ChatGPT, Codex, OpenCode started shipping agent harnesses that made most standalone agent frameworks redundant. That pushed us to the other side of the connection, the servers. If agents were going to consolidate into a few harnesses, then first-class integration with the rest of a company's systems (i.e. MCP) would become the thing that mattered, so we started building up our server SDKs.
Then in succession:
1. Oct 2025. ChatGPT Apps SDK. OpenAI brings app UIs to ChatGPT, built on top of MCP and the work of mcp-ui.\n2. Late 2025. The stores open. ChatGPT starts accepting app submissions, Claude grows its connector directory with selected partners.\n3. Jan 2026. MCP Apps becomes official. SEP-1865 merges as the first MCP extension (io.modelcontextprotocol/ui): one UI standard any host can render.
Today, all the major clients fully support MCP and are opening marketplaces of reviewed MCPs that can be one click installed. All major tech companies have an MCP server, and many of those are reporting that already 15+% of their usage comes from their MCP, and we start to have a good way to distribute them just now.
MCP can return fully interactive UIs. So companies can (1) display data in more meaningful ways to their users (e.g. analytics, ecommerce) and (2) display their branding in some of the most used products on the planet (ChatGPT, Claude etc). Numbers: an engineer at Amplitude reported that their MCP saw a 2x increase in retention after adding UI to their MCP.
Clients (Claude, ChatGPT, Cursor) are starting to dynamically present MCP servers/apps to users, based on their intent. Products will be organically discovered on the chats!
We feel that MCP is reaching its maturity moment. Now that MCPs are starting to be easy to install and discover, there is going to be a huge incentive for users to use them and for companies to create them:
1 - Most work is already done from AI chats, this is not going to stop, MCP gives you a way to interact with products without manually using their dashboards.
2 - MCP allows you to bring the context together in one place: you can read an email, create a ticket while plugged into the source code of your product, or your knowledge base. Aggregation of products that was not possible before, will happen in the chat, orchestrated by increasingly intelligent models.
If AI apps (Codex, Claude Desktop) are the new browsers, as PG said in a recent tweet https://x.com/paulg/status/2069080429236191504, then MCPs are the new websites.
But there is a catch:
- Submission process on the stores is still quite tricky, manual and takes up valuable time.\n- Hardly anybody knows how to design a good MCP: most of them are 1:1 proxies of the API and are abandoned, since being one shotted a few months ago.\n- The MCP Spec advances quickly and it is not easy to keep track of the changes, and what they mean for your server.\n- Auth is still a mystery for most teams (API key in the URL ???).\n- Most companies are not even aware that MCPs can return interactive UIs.\n- Clients still have to consolidate behavior, some do dynamic tool discovery, some don't, some persist authentication properly some don't.
We built Manufact and mcp-use to solve these problems.\nOur SDKs help them build good MCPs, our inspector helps them test locally, and our cloud helps them ship/publish and monitor them in production.
To deploy on Manufact you just need to connect a Github app, pick the repo, we'll detect the framework you are working with and get you a live MCP url as soon as possible.
In our platform, that live URL will be used to give you a chat where you can try/debug your MCP immediately and share it with your team. If you push an update on a new experimental branch, you'll be able to test that as well thanks to preview deployments.
Once your server is ready to go live, we help you make sure that it does not break. You can configure automated tests that will take your MCP server, install it in ChatGPT and Claude and test it. We do not test the model, we test the client (model + harness). This way you reliably know if your server breaks where people use it.
Since publishing on the store is a major distribution unlock for companies (your MCP can be dynamically discovered and one click installed across Claude\nproducts, and ChatGPT), we collected a set of requirements that will keep your submission from being rejected. You check this locally before going through the actual review process.
Once your server is live, you'll want to understand how it is used. Our analytics are designed for MCP, so you'll know how many users are hitting\nyour MCP, how many tool calls you receive, from which client.
You can try out https://manufact.com for free today. We have usage-based pricing and on our free account we give free credits for you to try it out. If you have an\nMCP already, just connect your Github repo and deploy, if not you can build one using our skill and SDKs pretty simply (we will guide you in the onboarding).
We would love to hear feedback about the product in the comments, and hear thoughts from everyone about MCP. Thanks! :)", "url": "https://manufact.com", "upvotes": 111, "comments": 70, "sub": "hackernews", "signal": 28.6, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "48480559", "title": "Show HN: Interbase – Long-running AI goals and aliases for any model", "body": "Hi HN,
I've been working on an open-source CLI agent called Interbase:
https://github.com/agentsorchestrationcompany/interbase
Two ideas motivated a lot of the project.
The first is that long-running agent workflows shouldn't be restricted to a small number of frontier models.
Many recent agent products are beginning to support persistent tasks, background work, and goal-oriented workflows. I think those capabilities are useful abstractions independent of the underlying model.
Interbase includes a `/goal` command that allows work to be organized around long-running objectives and supports more than 135 providers and 4,800+ models. The goal is to let users choose the model that works best for them rather than forcing a specific provider because a particular workflow feature only exists there.
The second idea is that AI workflows should be reusable in the same way shell workflows are.
Interbase includes `/aliases`, which allows users to create shortcuts for workflows they run frequently. For example, a user might create aliases such as:
`gcm` → preferred git commit workflow
`review` → code review workflow
`ship` → release readiness workflow
After a while these become muscle memory in much the same way traditional shell aliases do.
The project also includes encrypted remote access, and one of the next areas I'm exploring is computer use capabilities that can work across a broad range of models rather than a handful of specialized offerings.
I'm curious whether others think long-running goals and reusable workflows should live above the model layer, or whether they belong as model-specific capabilities.
Happy to answer questions about the implementation or design decisions.", "url": "https://github.com/agentsorchestrationcompany/interbase", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 28.1, "hits": [ "agent workflow", "code review workflow" ] }, { "src": "github", "id": "1233098702", "title": "rohithkandula19/Ronin", "body": "Masterless, terminal-native coding agent (Claude Code-style: reads, edits, runs code) for Claude, Gemini, Cerebras, Groq, and Ollama. Provider-agnostic with evals, memory, security hardening, 200+ plugins, and MCP. MIT. agent agentic-ai ai ai-agent anthropic claude claude-code cli coding-agent developer-tools gemini llm llm-agent mcp model-context-protocol ollama openrouter python terminal", "url": "https://github.com/rohithkandula19/Ronin", "upvotes": 1, "comments": 8, "sub": "github", "signal": 27.6, "hits": [ "claude code", "coding agent", "evals" ] }, { "src": "hackernews", "id": "47141347", "title": "Show HN: Open-source EU AI Act compliance layer for AI agents (8/2026 deadline)", "body": "We built AIR Blackbox — open-source compliance infrastructure for AI agents targeting the EU AI Act enforcement deadline on August 2, 2026.\nIf you're deploying LLM-based agents (LangChain, CrewAI, AutoGen, OpenAI Agents SDK) into production, the EU AI Act requires tamper-evident audit trails, human oversight mechanisms, data governance controls, and injection defense — for any system classified as high-risk.\nMost teams we've talked to either don't know about the deadline or assume their existing logging is enough. It's not. Article 12 specifically requires logs that regulators can mathematically verify haven't been altered. Article 14 requires the ability to interrupt agent execution. Article 15 requires defense against prompt injection and data poisoning.\nWhat we built:
Trust layers for LangChain, CrewAI, AutoGen, OpenAI Agents SDK, and RAG pipelines — each is a pip install that hooks into your existing agent code with ~3 lines of setup\nHMAC-SHA256 tamper-evident audit chains — every agent decision, tool call, and LLM interaction gets logged to a chain that regulators can verify\nConsentGate — risk-classifies tool calls and blocks critical operations until approved\nInjectionDetector — 15+ weighted patterns scanning prompts before they reach the model\nWriteGate + DriftDetector (for RAG) — prevents knowledge base poisoning and detects retrieval anomalies\nCompliance scanner — pip install air-compliance && air-compliance scan ./my-project tells you exactly which articles you're missing
Everything maps to specific EU AI Act articles (9, 10, 11, 12, 14, 15). Zero vendor lock-in, Apache 2.0, zero core dependencies on the trust layers.\nThe scanner is probably the fastest way to understand where your gaps are. It takes about 3 seconds to run on a typical project.\nGitHub: https://github.com/airblackbox\nPyPI: pip install air-compliance\nHappy to answer questions about what the EU AI Act actually requires for AI agent deployments — we've read the full regulation and mapped it to specific technical controls.", "url": "https://news.ycombinator.com/item?id=47141347", "upvotes": 2, "comments": 6, "sub": "hackernews", "signal": 27.3, "hits": [ "rag pipeline", "langchain", "autogen", "retrieval" ] }, { "src": "hackernews", "id": "41202694", "title": "Launch HN: Roe AI (YC W24) – AI-powered data warehouse to query multimodal data", "body": "Hey HN, we’re Richard and Jason from Roe AI (https://getroe.ai). We’re building a query engine that lets data people do SQL queries on various kinds of unstructured data (videos, images, webpages, documents) using LLM-powered data processors.
Here is a 3-minute video: https://www.youtube.com/watch?v=9-WwJk1v5mI, showing how to create an LLM data processor to process videos, build a semantic search for image data, and use it with SQL.\nThe problem we tackle is that data analysts cannot quickly answer their business questions around unstructured, multimodal data. For example, product teams want to understand user session replay videos to understand the painpoints of using their product. Ads teams need to know everything about an advertiser based on their web pages, such as the products they offer, payment methods, etc. Marketing teams need to know how product placement or music in a marketing campaign could get more views. And so on.
For data that is structured, questions like these can be answered quickly with SQL queries in Snowflake / BigQuery. But when you have unstructured multimodal data, it becomes a complex analysis process: open a Python notebook, write custom logic to get these multimodal data from blob storage (or write a crawler first if you need webpage data), find an AI model, do prompt engineering, do data ops to productionize the workload in a data workflow, etc.\nWe simplify this process to a few lines of SQL.
How it works: first, we leverage multimodal LLMs as data processors because they’re good at unstructured data information extraction, classification or any arbitrary tasks. Next, we’ve built a user interface for data people to explore multimodal data and manage AI components. Then we have a quick semantic index builder for multimodal data. (We often see databases provide vector search functionality but not indexing building, so we built that.) Utility functions deal with multimodal data, like video cutter, PDF page selector, etc. Finally, SQL is the command line for slicing and dicing multimodal data.
How we got here: I’ve experienced 3 data evolutions in the last 10 years. At UC Berkeley, I was a data researcher using a supercomputer cluster called Savio. It was a bare-metal way to analyze the data—I had to move CSV between machines. Then at LinkedIn, I had Hadoop + Pig / Scala Spark. That abstracted most of the work, but I spent hours tuning jobs and had a headache manipulating HDFS directories. Later I joined Snowflake, and was like, holy – data analysis can be this simple – I can just use SQL to do everything within this data warehouse! I asked myself: why can’t we make something like Snowflake for unstructured data? That was the impulse behind Roe.ai and it’s been driving me ever since.
To get started, you can sign in at https://app.roe-ai.com/ and there are docs at https://docs.roe-ai.com/. You can load unstructured data via our SQL and File API, Snowflake Staging Data Connector, S3 Blob Storage Data connector, Zapier Roe AI Zap, or the SQL function load_url_file() to get a file from a URL.
Some logistics: the product is free to start, and we’ve preloaded $50 AI credits—enough to process 3000 one-pager PDFs. If you use all $50, just email us, and we’ll give you more. The solution is not open-sourced because it is too complex to be self-hosted, but let us know if you see the potential for open-source.
The product is early and could have bugs and UX problems. It’d be incredible if you could give it a spin anyway and we hope it will be interesting and that you’ll let us know what you think!\nJason and I will be around in the thread and are really interested in hearing from you!", "url": "https://news.ycombinator.com/item?id=41202694", "upvotes": 60, "comments": 35, "sub": "hackernews", "signal": 27.0, "hits": [ "prompt engineering", "vector" ] }, { "src": "hackernews", "id": "48195021", "title": "Show HN: Superlog (YC P26) – Observability that installs itself and fixes bugs", "body": "Hey HN, we’re Nico and Arseniy, co-founders of Superlog (https://superlog.sh). We're building a self-installing, self healing observability tool meant not to be opened. It has a wizard that daily sets up proper logging and an agent that investigates errors and opens PRs.
Super short demo: https://www.youtube.com/watch?v=xFhU9Mk247M.
In our earlier startups, we tried Sentry, Datadog, Grafana, Dash0, and nothing was good enough. Proper telemetry and alerting still requires a ton of manual setup. We struggled with adding good logs, so debugging was tough, especially as codebases grow at a faster pace. Meanwhile, the Datadog/Dash0 bill kept climbing, and we still spent engineering hours to learn, configure, and maintain our observability tooling.
With Sentry, we found ourselves flooded by a stream of alerts into our Slack channel, most were duplicates or lacked context, so alert fatigue/constant interrupts were a real pain. The #ops notification is consistently the worst feeling on a Saturday morning
We’ve seen too many times servers run out of memory and disk, and three AWS metrics giving us three different values. Half of the graphs on dashboards are normally empty or outdated, and manually clicking through UIs, especially when the team is small, seems like a huge waste of time.
At some point we realized that solving this problem would be more valuable than the things we had been working on, and we had the expertise to do it, since Arseniy had spent years at Datadog, getting paged during the night to debug production incidents. So we decided to build a platform that would just work: agent-first, MCP-native, zero-setup.
Here’s how Superlog works: we have a wizard that scans your repo, and automatically instruments it with well-structured logs, traces and metrics via OpenTelemetry. We make sure to highlight main failure modes, endpoint performance, usage per tenant, and LLM/upstream cost (by callsite, tenant and model).
Errors get fingerprinted and grouped into incidents, so you see one issue, not a thousand duplicates. When you get a notification from Superlog, you see a clear failure summary, its inferred severity and impact upfront.
Then the agent investigates and tries to solve the issue. If it has enough context, it produces a concise and tested PR. If it doesn't, it posts its findings for the investigating team, and automatically pulls in the engineers that could contribute more context based on documentation, previous investigations and Slack threads.
Either way the output is one clean PR per incident, posted in Slack, that you can\nmerge, ignore, or open as a Claude Code session and modify.
Three things we think are different from other observability vendors:
(1) We solve the setup pain. The wizard will instrument everything with native OTel SDKs, respecting the semantic conventions, with proper service and environment tagging. We’re also working on native automatic dashboards and alerts, so that you can see what’s going on in a glance and don’t miss subtle failure modes.
(2) Our telemetry doesn’t decay. The wizard runs daily, and keeps adding logs, alerts and dashboards where it’s needed. You don't have to remember to instrument new features. The next time something breaks, the data you need to debug it is already there.
(3) Our goal is to solve alert fatigue. We use agents to merge similar errors and refine the summaries, giving you relevant information upfront. We have a custom evaluation setup that makes sure that our summaries are dense and correct, and severity and impact is on point. We also give you confidence scores for every LLM-enhanced metric so that wrong guesses don’t get boosted.
Important: superlog telemetry is vendor-neutral, so you keep all the logs/metrics/traces we install. Pricing is on the site. We're early, so expect rough edges and please tell us when you find them.
You can try it at https://superlog.sh. We'd love to hear what you're using today, what's broken about it, and whether the "one mergeable PR per incident" model sounds useful or terrifying. Especially keen to hear from folks running integration-heavy products, anyone who's rolled their own observability, and anyone who has tried Sentry / Datadog MCPs and given up. Comments and feedback welcome!", "url": "https://superlog.sh/", "upvotes": 74, "comments": 49, "sub": "hackernews", "signal": 26.7, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "43683075", "title": "Show HN: A library to convert+deploy existing agent projects as MCP servers", "body": "Most of the MCP servers that I’ve seen are tools implemented in standalone projects. To onboard more tools (especially agents and multi-agent workflows) to MCP, I’ve been thinking it’s important to allow AI engineers to continue to prototype in their existing agent frameworks and deploy with minimal conversion when ready.
We created the automcp library, which you can add as a dependency to existing projects (CrewAI, LangGraph, Llama Index, OpenAI Agents SDK, Pydantic AI, mcp-agent currently supported but more coming soon). You just need to run a CLI command to create a run_mcp.py file, make some edits and run it to start the server locally. You can think of run_mcp.py like Heroku’s Procfile, Codespaces configs, Pulumi/AWS CDK style IaC.
We also created a demo of a deployment platform where you can enter the GitHub URL of your project, deploy with one click, and get a URL for the hosted sse server that can be used with MCP clients like Cursor. Think of it like Vercel for MCP servers.
There are still a few manual steps for the user that can be further automated, but curious to hear whether people think it’s useful? There are some interesting directions automcp could go in in future like automatically creating MCP servers for each orchestrator, agent and tool in a project (rather than one monolithic MCP server).
Website: https://auto-mcp.com\nautomcp repo: https://github.com/NapthaAI/automcp \nDeployment platform: https://labs.naptha.ai/ \nDemo: https://www.youtube.com/watch?v=El5YvBQ5py0", "url": "https://github.com/NapthaAI/automcp", "upvotes": 22, "comments": 2, "sub": "hackernews", "signal": 26.5, "hits": [ "agent workflow", "langgraph" ] }, { "src": "hackernews", "id": "44660406", "title": "Show HN: Single-agent long-horizon reasoning within one LLM run", "body": "- We build the Thread Inference Model (TIM) based on the transformer architecture, and its dedicated runtime TIMRUN.
- TIM + TIMRUN = Intelligent workflow generation, context engineering, and multi-hop tool use happens at the runtime level
- TIM + TIMRUN supports virtually unlimited reasoning enabled by context pruning, significantly improves the efficiency for long-horizon reasoning tasks
- Inference API is live at https://subconscious.dev/
- More details: https://github.com/subconscious-systems/TIMRUN", "url": "https://huggingface.co/papers/2507.16784", "upvotes": 4, "comments": 1, "sub": "hackernews", "signal": 26.4, "hits": [ "context engineering", "tool use" ] }, { "src": "hackernews", "id": "43477861", "title": "Show HN: Typia (20,000x faster validator) challenges to Agentic AI with compiler", "body": "- typia is a runtime validator using the TypeScript compiler API, and automatically generates validators, serialized, JSON schema, etc. by analyzing source code at compile time
- Agentica: Challenges the Agentic AI Framework by utilizing typia compiler skills, specializing in LLM Function Calling
- Agentica argues that everything can be done with LLM Function Calling, avoiding the agent workflow graph used in traditional AI agent development, and therefore developers should focus on the function unit
- Scalable, flexible, and mass-productive agent development possible by focusing on the function unit\n- Compiler Driven Development for safe and efficient function schema build
- Document Driven Development by separating the function unit prompt domain for enterprise-level agent development", "url": "https://typia.io/articles/typia-challenges-to-agentic-ai-with-its-compiler-skill.html", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 26.1, "hits": [ "agent workflow", "function calling" ] }, { "src": "hackernews", "id": "47034087", "title": "Evaluating AGENTS.md: are they helpful for coding agents?", "body": "", "url": "https://arxiv.org/abs/2602.11988", "upvotes": 232, "comments": 161, "sub": "hackernews", "signal": 26, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "47431671", "title": "Show HN: Duplicate 3 layers in a 24B LLM, logical deduction .22→.76. No training", "body": "I replicated David Ng's RYS method (https://dnhkng.github.io/posts/rys/) on consumer AMD GPUs \n(RX 7900 XT + RX 6950 XT) and found something I didn't expect.
Transformers appear to have discrete "reasoning circuits" — contiguous blocks of 3-4 layers that \nact as indivisible cognitive units. Duplicate the right block and the model runs its reasoning \npipeline twice. No weights change. No training. The model just thinks longer.
The results on standard benchmarks (lm-evaluation-harness, n=50):
Devstral-24B, layers 12-14 duplicated once:\n- BBH Logical Deduction: 0.22 → 0.76\n- GSM8K (strict): 0.48 → 0.64\n- MBPP (code gen): 0.72 → 0.78\n- Nothing degraded
Qwen2.5-Coder-32B, layers 7-9 duplicated once:\n- Reasoning probe: 76% → 94%
The weird part: different duplication patterns create different cognitive "modes" from the same \nweights. Double-pass boosts math. Triple-pass boosts emotional reasoning. Interleaved doubling \n(13,13,14,14,15,15,16) creates a pure math specialist. Same model, same VRAM, different routing.
The circuit boundaries are sharp — shift by one layer and the effect disappears or inverts. \nSmaller models (24B) have tighter circuits (3 layers) than larger ones (Ng found 7 layers in 72B).
Tools to find circuits in any GGUF model and apply arbitrary layer routing are in the repo. \nThe whole thing — sweep, discovery, validation — took one evening.
Happy to answer questions.", "url": "https://github.com/alainnothere/llm-circuit-finder", "upvotes": 265, "comments": 80, "sub": "hackernews", "signal": 26, "hits": [ "benchmark" ] }, { "src": "hackernews", "id": "48002136", "title": "DeepClaude – Claude Code agent loop with DeepSeek V4 Pro", "body": "", "url": "https://github.com/aattaran/deepclaude", "upvotes": 678, "comments": 281, "sub": "hackernews", "signal": 26, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "47674729", "title": "Show HN: AgentLint – ESLint for your coding agents", "body": "I’ve been spending a lot of time with coding agents lately. Across Claude Code, Cursor, OpenCode, Codex, and different models, I kept noticing that some people were getting much better results from the same tools. It became clear that this was not just about prompting.
A big part of it was context drift. AGENTS.md, skills, rules, and workflows looked fine, but were no longer aligned with the code.
I also learned that more context does not always help. Sometimes it adds noise and wastes tokens. The recent AGENTS.md paper also pushed me to think harder about this, especially around auto-generated context files and /init-style workflows.
Then I saw Microsoft’s writeup showing a jump from 38.1% to 69% after improving instruction setup. That made me take these files much more seriously.
AgentLint came out of that. It’s a small CLI that scans the repo and helps keep context files aligned. After setup, MCP handles most of the ongoing flow.
Give it a try: npx @agent-lint/cli
http://samilozturk.github.io/agentlint
Would really appreciate any feedback or criticism.", "url": "https://github.com/samilozturk/agentlint", "upvotes": 4, "comments": 3, "sub": "hackernews", "signal": 25.8, "hits": [ "claude code", "coding agent" ] }, { "src": "hackernews", "id": "42381139", "title": "Show HN: Gentrace – connect to your LLM app code and run/eval it from a UI", "body": "Hey HN - Doug from Gentrace here. We originally launched via Show HN in August of 2023 as evaluation and observability for generative AI: https://news.ycombinator.com/item?id=37238648
Since then, everyone from the model providers to LLM ops companies built a prompt playground. We had one too, until we realized this was totally the wrong approach:
- It's not connected to your application code
- They don't support all models
- You have to rebuild evals for just this one prompt (can't use your end-to-end evals)
In other words, it was a ton of work and time to use these to actually make your app better. So, we built a new experience and are relaunching around this idea:
Gentrace is a collaborative LLM app testing and experimentation platform that brings together engineers, PMs, subject matter experts, and more to run and test your actual end-to-end app.
To do this, use our SDK to:
- connect your app to Gentrace as a live runner over websocket (local) / via webhook (staging, prod)
- wrap your parameters (eg prompt, model, top-k) so they become tunable knobs in the front end
- edit the parameters and then run / evaluate the actual app code with datasets and evals in Gentrace
We think it's great for tuning retrieval systems, upgrading models, and iterating on prompts.
It's free to trial. Would love to hear your feedback / what you think!", "url": "https://gentrace.ai/", "upvotes": 23, "comments": 3, "sub": "hackernews", "signal": 25.8, "hits": [ "llm ops", "evals", "retrieval" ] }, { "src": "hackernews", "id": "48346958", "title": "Show HN: Agents, run any coding agent on your subscription not API costs", "body": "Hi HN. I'm the founder of Phoenix Labs (ex TikTok, Applied AI) and we're open sourcing our internal tooling today which is like a toolchain / meta-harness for CLI agents useful for really scaling eng and creative work.
We are a very small team who's building a very ambitious product so we had to find ways to squeeze every ounce of efficiency that we could get our hands on. Harness strengths of different models (Claude, GPTs) and CLI-harnesses (Claude Code, Codex), safe/robust browser integration to speed up UX/QA testing, teams cli to speed up security reviews and parallelize bug hunting and fixes, and secrets cli with touch id integration so DX is extremely fast.
We also noticed that small things like installing marketplaces, or sharing resources per projects (skills, plugins, secrets, subagents, workflows, rules, permission groups, hooks) took a lot of time so we put everything under ~/.agents and supported multi-layer dot-agents repos, auto layering and syncing system, user and project level resources and extra so teams can have their own dot-agents repos
Fun things like auto-rotation of CC credentials to tackle session limits also exist and save a lot of time. We usually have multiple agent versions installed per agent type.
CLI is called `agents` and it injects shims for `claude`, `codex` and other agents. When we need a new feature like routines for keeping CI healthy, we just implement it in a way that's compatible with most commonly uses agent-harnesses at our company including Claude Code, Codex, Antigravity/Gemini, Cursor/Grok CLI and more
Install:
curl -fsSL agents-cli.sh/install.sh | sh\n# or: bun install -g @phnx-labs/agents-cli
Source: https://github.com/phnx-labs/agents-cli
Honest limits: macOS works best. Linux works. Touch ID is macOS only. But, it's MIT :)
Want feedback on the developer experience. And my apologies if your agent harness is not supported throughout. Please feel free to make a PR and happy to hop on a chat/call
Muqsit", "url": "https://agents-cli.sh", "upvotes": 6, "comments": 2, "sub": "hackernews", "signal": 25.7, "hits": [ "claude code", "coding agent" ] }, { "src": "github", "id": "1167246588", "title": "skynetcmd/m3-memory", "body": "Local-first Memory Framework for AI Agents · 99.2% LongMemEval-S retrieval @ k=10 · Supports Claude · Antigravity · LangChain · Hermes · Gemini · OpenCode · OpenClaw · MCP-native and plugins · Hybrid search (FTS5 + vector + MMR) · GDPR · FIPS 140-3 ready · 100% local (fully offline) or cloud capable agent-memory agentic-memory ai-agents ai-memory claude-code fips-140-3 gdpr gemini-cli langchain langgraph langmem local-llm long-term-memory-llm mcp mcp-server mem0 openclaw privacy rag vector-search", "url": "https://github.com/skynetcmd/m3-memory", "upvotes": 22, "comments": 3, "sub": "github", "signal": 25.7, "hits": [ "langchain", "langgraph", "retrieval", "vector" ] }, { "src": "hackernews", "id": "37777683", "title": "Show HN: HoneyHive – An unified evaluation and monitoring platform for LLM apps", "body": "Hey HN! We’re Mohak and Dhruv from HoneyHive (https://honeyhive.ai). HoneyHive is a set of tools built around evaluating, monitoring, and iteratively improving LLM systems to make them production-ready and reliable.
We’re sure everyone has seen the general bugginess LLMs introduce into products and how hard it is to improve these models. Most LLM products are generally assumed to be buggy, and everyone treats them as such – it works well sometimes, but I won’t bet on it. This is obviously not going to work in production at scale.
Most teams we talked to want to iterate and improve their LLM apps, much like what they’ve been doing for decades with traditional software, but the tooling and workflows to do so are broken in many ways:
- Offline evaluations are manual, time-consuming and costly
- Product analytics tools used to track user feedback aren’t built to handle unstructured data
- In more complex pipelines like autonomous agents or RAG, the LLM is not the only issue – vector databases and other APIs are often the bigger issue, making it hard to debug
As we see it, the typical workflow across most companies is: OpenAI Playground -> LangChain/CLI for prototyping -> Google Sheets for evaluations -> Mixpanel, Sentry, or Streamlit/Retool for monitoring. This flow doesn’t scale to multi-step LLM pipelines like agents or RAG, let alone multimodality. We are convinced that companies here will decide to buy external tooling instead of slowing themselves down and wasting valuable developer time maintaining these internal tools - given how quickly OpenAI’s schemas keep evolving
We both saw this workflow at Microsoft & Templafy before starting HoneyHive, so we aimed to build a tool that works from the prototype stage to scaling in production. From the start, we focused on building abstractions that generalize across a single LLM and multimodal agents.
- Studio: Our Playground integrates into any model that follows OpenAI API schema and can call an arbitrary javascript block as a “tool” - this allows us to integrate across vector dbs, search APIs, etc. Aimed to help teams collaborate early in the prototyping phase
- Offline Evaluations: Our Evaluations SDK is based on arbitrary configuration dictionaries and I/O schemas, extending quickly across single prompts, agents, chains, and RAG pipelines. Our Metric interface can then ingest LLM stack traces and compute metrics across every step during testing and monitoring.
- Online Monitoring: Here, we took heavy inspiration from product, software & ML observability to marry them for multimodal LLM pipelines. The schemas are highly configurable, allowing you to enrich each event with any config properties, custom metadata, user properties, feedback or metrics - all of which can be used to slice and dice your data to discover trends and anomalies
Here’s a full demo: https://www.loom.com/share/e36aecf20f09428b8b2172d8fb4be1ff?sid=07242547-db5e-471d-a8d3-760c0f4bc513
We have enabled multiple companies with this stack. MultiOn, a company building a multimodal browser agent, has used our platform to evaluate and monitor their agent, and fine-tune open source models for acting on browser DOMs. They have set up moderation filters in prod, using our Metrics docker environment to run an arbitrary Python code-block or an LLM evaluation function over logs to enrich it. They’ve also integrated our eval pipelines with their fine-tuning pipelines, allowing them to automatically benchmark any new fine-tuned models and automate the data flywheel.
We launched our public beta yesterday and will be making the platform open for general access in the coming weeks! We apologize for the public beta form before login haha.
As you can imagine, building a developer platform for multimodal agents is an intricate engineering challenge, so any feedback from the HN community will be very helpful for us! We look forward to hearing your thoughts, questions and feedback!", "url": "https://news.ycombinator.com/item?id=37777683", "upvotes": 3, "comments": 2, "sub": "hackernews", "signal": 25.6, "hits": [ "rag pipeline", "langchain", "benchmark", "vector" ] }, { "src": "hackernews", "id": "46990733", "title": "Show HN: 20+ Claude Code agents coordinating on real work (open source)", "body": "Single-agent LLMs suck at long-running complex tasks.
We’ve open-sourced a multi-agent orchestrator that we’ve been using to handle long-running LLM tasks. We found that single LLM agents tend to stall, loop, or generate non-compiling code, so we built a harness for agents to coordinate over shared context while work is in progress.
How it works:\n1. Orchestrator agent that manages task decomposition\n2. Sub-agents for parallel work\n3. Subscriptions to task state and progress\n4. Real-time sharing of intermediate discoveries between agents
We tested this on a Putnam-level math problem, but the pattern generalizes to things like refactors, app builds, and long research.\nIt’s packaged as a Claude Code skill and designed to be small, readable, and modifiable.
Use it, break it, tell me about what workloads we should try and run next!", "url": "https://github.com/mutable-state-inc/lean-collab", "upvotes": 53, "comments": 39, "sub": "hackernews", "signal": 25.4, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "47170501", "title": "Ask HN: Why do AI coding agents refuse to save their own observations?", "body": "I've spent months building tooling for AI coding agents and hit something I can't fully explain.
If you give an agent (Claude Code, Cursor, Codex) a tool to save observations — "save_observation: persist this insight for future sessions" — and explicitly instruct it to use the tool in system prompts, config files, everywhere you can, it calls it maybe 30% of the time.
The agent will happily use tools that help it complete the current task. But a tool that only benefits future sessions? Almost never.
My working theory: these models are optimized for task completion within the current context window. Saving an observation has zero value for the current task — it's a token cost with no immediate reward. The model has learned that every token spent on "let me save this for later" is a token not spent on the actual work. The incentive structure is wrong at the training level.
I ended up building a passive observation system that watches what the agent does and infers observations from tool calls and AST-level code diffs, without requiring agent cooperation. But I'm curious if others have found ways to make agents reliably self-document.
Has anyone solved this? Techniques like:\n- Prompt structures that actually get agents to save context\n- Fine-tuning approaches that reward knowledge retention\n- Alternative architectures for persistent agent memory
Or is passive observation the only reliable path when the agent won't cooperate?", "url": "https://news.ycombinator.com/item?id=47170501", "upvotes": 2, "comments": 1, "sub": "hackernews", "signal": 25.3, "hits": [ "claude code", "coding agent" ] }, { "src": "hackernews", "id": "45053581", "title": "Show HN: Devplan – Generate specs and coding prompts with deep context", "body": "Hi, I’m Chris and my partners and I are building Devplan, an AI product development tool that helps teams go from idea to working code faster.
What Devplan does:
- Creates deep contextual understanding from Github and the web with our open source context engine: https://github.com/devplaninc/contextify
- Generates right-sized PRDs, user stories, and tech design based on company context
- Gives a ballpark effort and complexity estimate for every user story
- Breaks down requirements into structured coding prompts for tools like Claude Code, Cursor, Windsurf, or JetBrains Junie
- Integrates with Linear and Jira to push generated project docs and tickets to your tracking system
- Lets you kick off projects with images to refine specs with mocks, diagrams, or screenshots
- Exports detailed coding prompts as standalone files or use our CLI to work with them directly
Why we built it:
We believe the next generation of product development will be built with AI at its core. But we’ve seen first-hand how the current tools fall short:
- Docs from ChatGPT or Claude are useful but too general and lack context for real workflows
- AI coding agents lose context quickly in large repos and generated code often requires re-work
- Most approaches to planning for AI coding takes too long and isn't shared or reviewed, which slows teams down
AI should remove that friction, not create more of it. We built Devplan to make planning and execution one connected flow. It starts with outcomes, adapts to the size of your project, and produces structured inputs for the coding tools you already use. Instead of bouncing between AI assistants, PM docs, and code editors, Devplan ties it all together so you can move faster without losing context.
We have an MVP template for side projects, but the platform is being built for real teams who want to ship product with confidence while staying lean. We are still early and we’re iterating quickly.
Would love to hear feedback from other builders. What’s working for you when it comes to planning and building with AI?
P.S. If you want to try it, public beta is open: https://www.devplan.com", "url": "https://www.devplan.com/", "upvotes": 6, "comments": 0, "sub": "hackernews", "signal": 25.3, "hits": [ "claude code", "coding agent" ] }, { "src": "hackernews", "id": "47125210", "title": "Show HN: Irpapers – Visual embeddings vs. OCR trade-offs in scientific PDFs", "body": "Hey HN, we are releasing IRPAPERS to answer a highly pragmatic question: when building a RAG pipeline over PDFs, should you OCR the text or just embed the raw page images?
Processing PDFs in production usually involves stringing together brittle OCR heuristics. While recent multimodal embeddings (like ColModernVBERT or ColPali) allow you to skip OCR entirely and retrieve directly from visual layouts, we wanted to measure if the computational overhead is actually worth the utility.
The short answer: Transformer-based image pipelines won't be perfect for every use-case, but they fix exactly what OCR breaks.
Here is what we found benchmarking 3,230 pages of dense scientific literature:
Complementary Bottlenecks: Text representations (BM25 + dense vectors) are highly efficient for exact lexical constraints (e.g., finding a specific acronym like "HyDE"). Conversely, image embeddings shine on spatial architecture diagrams and t-SNE plots where OCR serialization just turns into structural garbage.
Multimodal Hybrid Search: Because these failure modes are almost perfectly orthogonal, fusing the two signals gives you the best performance out of the box. By combining them, we pushed top-1 recall to 49% (beating text alone at 46%).
The Memory Constraint: Late-interaction image embeddings produce thousands of vectors per page, creating a massive storage bottleneck. To address this need, we evaluate MUVERA encoding. Under the hood, this compresses multi-vector representations into a single fixed-dimensional encoding via SimHash, allowing you to use standard HNSW indexing without the paralyzing memory overhead.
In practice, if you are building a RAG workflow today, text-based context still provides higher downstream utility for the actual generation step (0.82 vs 0.71 alignment). Instead of picking one modality and dealing with its blind spots, start with hybrid text search as a sensible default, and inject multi-vector image embeddings to catch the visual edge-cases.
We’ve open-sourced the benchmark and the evaluation recipes:
Paper https://arxiv.org/abs/2602.17687\nIRPAPERS dataset on HuggingFace at huggingface.co/weaviate/IRPAPERS and GitHub\nat github.com/weaviate/IRPAPERS
Our experimental code is also available on GitHub at\ngithub.com/weaviate/query-agent-benchmarking
Happy to answer any questions about the evaluation pipeline, the cold start problem of visual benchmarks, or the specific retrieval trade-offs we saw.", "url": "https://github.com/weaviate/query-agent-benchmarking", "upvotes": 5, "comments": 0, "sub": "hackernews", "signal": 25.2, "hits": [ "rag pipeline", "benchmark", "retrieval", "vector" ] }, { "src": "hackernews", "id": "48558502", "title": "Show HN: A policy gate that runs before your AI coding agent's tool calls", "body": "As a Security Engineer with over 10+ years in industry, I kept running into the same problem with coding agents: Instructions are not guarantees.
I put guidance in `CLAUDE.md`, `AGENTS.md`, memory files, MCP descriptions, and tool documentation. I explicitly told the agent things like:
- Use the code graph for architecture questions instead of grepping the repository.\n- Do not use deprecated APIs or Unsafe code.\n- Prefer specific tools for specific tasks.
The agent would still ignore those instructions surprisingly often. It would grep the entire repo, use deprecated APIs, or choose a slower tool even when a better one was available.
That made me realize prompts and rules solve different problems.
A prompt is a probabilistic influence on model behavior. A rule is an enforcement mechanism.
So I built SSG (SigmaShake Governance), which sits between the agent and its tools. Instead of asking the model to remember a policy, SSG evaluates every tool call before it executes.
For example, this rule redirects architecture-related repository searches away from recursive grep and toward a code graph:
```text\nrule route-codebase-grep-to-graph {\n enable true\n priority 80\n severity warning\n CATEGORY tool-routing\n FORCE search\n IF tool EQUALS "Grep"\n MESSAGE "Architecture, relationship, and dependency questions are routed to the code-graph tool."\n SUBSTITUTE "graphify query \\"<what you were searching for>\\""\n}\n```
When the agent attempts a grep for an architecture question, the call is redirected. If it attempts to write deprecated code, the write can be blocked before the content reaches disk and the replacement API can be suggested.
A few design choices:
- Rules are plain text and git-versioned.\n- Enforcement runs locally.\n- The same rules work across Claude Code, Codex, Cursor, Gemini, and MCP-based agents.\n- Bypasses are allowed, but recorded.\n- The goal is not to sandbox a hostile model; it's to prevent routine agent mistakes and shortcuts.
I found that many existing controls operate either too early or too late:
- Prompt files influence behavior but don't enforce it.\n- Tool allowlists are often all-or-nothing.\n- Pre-commit hooks catch problems after files have already been written.\n- Harness-specific permissions don't travel with the repository. (what if your team does not use the same harness?)
If you do not live in the terminal, SigmaShake Desktop is the same governance dashboard with no CLI required: a free direct download for macOS, Windows, and Linux. The Mac App Store and Microsoft Store also carry it as a paid, sandboxed build that auto-updates and skips the Gatekeeper and SmartScreen prompts, if you would rather pay once for the managed install (or just want to support the project):\nhttps://apps.apple.com/us/app/sigmashake-desktop/id676990115...\nhttps://apps.microsoft.com/detail/9N2CHV3STGS4
I've been building this in public for a few months.\nhttps://twitch.tv/sigmashake\nhttps://youtube.com/@sigmashakeinc
What instructions do your agents consistently ignore?", "url": "https://sigmashake.com", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 25.1, "hits": [ "claude code", "coding agent" ] }, { "src": "hackernews", "id": "47161330", "title": "Show HN: Projekt [Free Alpha] – All-in-one workspace for building with agents", "body": "I'm a product designer & front-end engineer who's been building with AI coding agents for the past year and working on teams launching AI products even longer. I always found the tools to be powerful, but the workflow around them lacking. I was constantly bouncing between terminals, browsers, file managers, and a rotating cast of IDEs. Nothing ever hit the right balance of simplicity and control.
So, like any completely over-burdened dad and leader, I built my own. Projekt is an agent-agnostic workspace that consolidates everything into one place. Bring your own key, bring your own agent — Claude Code, Codex, Gemini, Opencode, whatever you prefer.
It's still early. The alpha is free and I'm looking for people to help find rough edges and squash bugs. I've built 2 apps using it so far and the experience has been exactly what I was looking for. My roadmap is public and I plan to develop it rapidly.
Download the free alpha at https://getprojekt.com or grab the Founders Tier.
Happy to answer any questions about the architecture, the design decisions, or the agent-agnostic approach.
Thanks!", "url": "https://www.getprojekt.com/", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 25.1, "hits": [ "claude code", "coding agent" ] }, { "src": "hackernews", "id": "39917364", "title": "Show HN: Burr – A framework for building and debugging GenAI apps faster", "body": "Hey HN, we're developing Burr (github.com/dagworks-inc/burr), an open-source python framework that makes it easier to build and debug GenAI applications.
Burr is a lightweight library that can integrate with your favorite tools and comes with a debugging UI. If you prefer a video introduction, you can watch me build a chatbot here: https://www.youtube.com/watch?v=rEZ4oDN0GdU.
Common friction points we’ve seen with GenAI applications include logically modeling application flow, debugging and recreating error cases, and curating data for testing/evaluation (see https://hamel.dev/blog/posts/evals/). Burr aims to make these easier. You can run Burr locally – see instructions in the repo.
We talked to many companies about the pains they felt in building applications on top of LLMs and were surprised how many built bespoke state management layers and used printlines to debug.
We found that everyone wanted the ability to pull up the state of an application at a given point, poke at it to debug/tweak code, and use for later testing/evaluation. People integrating with LLMOps tools fared slightly better, but these tend to focus solely on API calls to test & evaluate prompts, and left the problem of logically modeling/checkpointing unsolved.
Having platform tooling backgrounds, we felt that a good abstraction would help improve the experience. These problems all got easier to think about when we modeled applications a state machines composed of “actions” designed for introspection (for more read https://blog.dagworks.io/p/burr-develop-stateful-ai-applicat...). We don’t want to limit what people can write, but we do want to constrain it just enough that the framework provides value and doesn’t get in the way. This led us to design Burr with the following core functionalities:
1. BYOF. Burr allows you to bring your own frameworks/delegate to any python code, like LangChain, LlamaIndex, Hamilton, etc. inside of “actions”. This provides you with the flexibility to mix and match so you’re not limited.
2. Pluggability. Burr comes with APIs to allow you to save/load (i.e. checkpoint) application state, run custom code before/after action execution, and add in your own telemetry provider (e.g. langfuse, datadog, DAGWorks, etc.).
3. UI. Burr comes with its own UI (following the python batteries included ethos) that you can run locally, with the intent to connect with your development/debugging workflow. You can see your application as it progresses and inspect its state at any given point.
The above functionalities lend themselves well to building many types of applications quickly and flexibly using the tools you want. E.g. conversational RAG bots, text based games, human in the loop workflows, text to SQL bots, etc. Start with LangChain and then easily transition to your custom code or another framework without having to rewrite much of your application. Side note: we also see Burr as useful outside of interactive GenAI/LLMs applications, e.g. building hyper-parameter optimization routines for chunking and embeddings & orchestrating simulations.
We have a swath of improvements planned. We would love feedback, contributions, & help prioritizing. Typescript support, more ergonomic UX + APIs for annotation and test/eval curation, as well as integrations with common telemetry frameworks and capture of finer grained information from frameworks like LangChain, LlamaIndex, Hamilton, etc…
Re: the name Burr, you may recognize us as the authors of Hamilton (github.com/dagworks-inc/hamilton), named after Alexander Hamilton (the creator of the federal reserve). While Aaron Burr killed him in a duel, we see Burr being a complement, rather than killer to Hamilton !
That’s all for now. Please don’t hesitate to open github issues/discussions or join our discord https://discord.gg/6Zy2DwP4f3 to chat with us there. We’re still very early and would love to get your feedback!", "url": "https://github.com/DAGWorks-Inc/burr", "upvotes": 94, "comments": 22, "sub": "hackernews", "signal": 25.1, "hits": [ "langchain", "evals" ] }, { "src": "github", "id": "1257504946", "title": "Vuongngu8186/langgraph-langchain-agent-setup", "body": "Deploy a complete LangGraph and LangChain agent workflow on Windows 10 or 11 with this clean, pre-configured build. agent-framework agent-workflow ai anthropic chatgpt deepagents enterprise gemini-api generative-ai java langgraph llama llm llm-agent milvus ollama onnx pinecone workflow", "url": "https://github.com/Vuongngu8186/langgraph-langchain-agent-setup", "upvotes": 0, "comments": 0, "sub": "github", "signal": 25.0, "hits": [ "agent workflow", "langchain", "langgraph" ] }, { "src": "hackernews", "id": "46665393", "title": "Show HN: GibRAM an in-memory ephemeral GraphRAG runtime for retrieval", "body": "Hi HN,
I have been working with regulation-heavy documents lately, and one thing kept bothering me. Flat RAG pipelines often fail to retrieve related articles together, even when they are clearly connected through references, definitions, or clauses.
After trying several RAG setups, I subjectively felt that GraphRAG was a better mental model for this kind of data. The Microsoft GraphRAG paper and reference implementation were helpful starting points. However, in practice, I found one recurring friction point: graph storage and vector indexing are usually handled by separate systems, which felt unnecessarily heavy for short-lived analysis tasks.
To explore this tradeoff, I built GibRAM (Graph in-buffer Retrieval and Associative Memory). It is an experimental, in-memory GraphRAG runtime where entities, relationships, text units, and embeddings live side by side in a single process.
GibRAM is intentionally ephemeral. It is designed for exploratory tasks like summarization or conversational querying over a bounded document set. Data lives in memory, scoped by session, and is automatically cleaned up via TTL. There are no durability guarantees, and recomputation is considered cheaper than persistence for the intended use cases.
This is not a database and not a production-ready system. It is a casual project, largely vibe-coded, meant to explore what GraphRAG looks like when memory is the primary constraint instead of storage. Technical debt exists, and many tradeoffs are explicit.
The project is open source, and I would really appreciate feedback, especially from people working on RAG, search infrastructure, or graph-based retrieval.
GitHub: https://github.com/gibram-io/gibram
Happy to answer questions or hear why this approach might be flawed.", "url": "https://github.com/gibram-io/gibram", "upvotes": 60, "comments": 9, "sub": "hackernews", "signal": 24.8, "hits": [ "rag pipeline", "retrieval", "vector" ] }, { "src": "hackernews", "id": "47545642", "title": "Show HN: Open-Source Animal Crossing–Style UI for Claude Code Agents", "body": "We posted here on Monday and got some great feedback. We’ve implemented a few of the most requested updates:
- iMessage channel support (agents can text people and you can text agents) Other channels are simple to extend.\n- A built-in browser (agents can navigate and interact with websites)\n- Scheduling (run tasks on a timer / cron/ in the future)\n- Built in tunneling so that the agents can share local stuff with you over the internet\n- More robust MCP and Skills support so anyone can extend it\n- 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!", "url": "https://github.com/outworked/outworked/releases/tag/v0.3.0", "upvotes": 48, "comments": 36, "sub": "hackernews", "signal": 24.6, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "39042093", "title": "Launch HN: Talc AI (YC S23) – Test Sets for AI", "body": "Hey all! Max and Matt here from Talc AI. We do automated QA for anything built on top of an LLM. Check out our demo: https://talc.ai/demo
We’ve found that it's very difficult to know how well LLM applications (and especially RAG systems) are going to work in the wild. Many companies tackle this by having developers or contractors run tests manually. It’s a slow process that holds back development, and often results in unexpected behavior when the application ships.
We’ve dealt with similar problems before; Max was a staff engineer working on systematic technical solutions for privacy problems at facebook, and Matt worked on ML ops on facebooks’ election integrity team, helping run classifiers that handled trillions of data points. We learned that even the best predictive systems need to be deeply understood and trusted to be useful to product teams, and set out to build the same understanding in AI.
To solve this, we take ideas from academia on how to benchmark the general capabilities of language models, and apply them to generating domain specific test cases that run against your actual prompts and code.
Consider an analogy: If you’re a lawyer, we don’t need to be lawyers to open up a legal textbook and test your knowledge of the content. Similarly if you’re building a legal AI application, we don’t need to build your application to come up with an effective set of tests that can benchmark your performance.
To make this more concrete - when you pick a topic in the demo, we grab the associated wikipedia page and extract a bunch of facts from it using a classic NLP technique called “named entity recognition”. For example if you picked FreeBASIC, we might extract the following line from it:
Source of truth: "IDEs specifically made for FreeBASIC include FBide and FbEdit,[5] while more graphical options include WinFBE Suite and VisualFBEditor." \n\n Question: "What programming language are the IDEs WinFBE Suite and FbEdit designed to support?"\n Reference Answer: "FreeBasic"\n\nIn production we’re building this same functionality on our customers' knowledge base instead of wikipedia. We then employ a few different strategies to generate questions – these range from simple factual questions like “how much does the 2024 chevy tahoe cost”, to complex questions like “What would a mechanic have to do to fix the recall on my 2018 Golf?” These questions are based on facts extracted from your knowledge base and real customer examples.
This testing and grading process is fast – it’s driven by a mixture of LLMs and traditional algorithms, and can turn around in minutes. Our business model is pretty simple - we charge for each test created. If you opt to use our grading product as well we charge for each example graded against the test.
We’re excited to hear what the HN community thinks – please let us know in the comments if you have any feedback, questions or concerns!", "url": "https://news.ycombinator.com/item?id=39042093", "upvotes": 132, "comments": 47, "sub": "hackernews", "signal": 24.6, "hits": [ "benchmark" ] }, { "src": "hackernews", "id": "47602986", "title": "Show HN: Real-time dashboard for Claude Code agent teams", "body": "This project (Agents Observe) started as an exploration into building automation harnesses around claude code. I needed a way to see exactly what teams of agents were doing in realtime and to filter and search their output.
A few interesting learnings from building and using this:
- Claude code hooks are blocking - performance degrades rapidly if you have a lot of plugins that use hooks
- Hooks provide a lot more useful info than OTEL data
- Claude's jsonl files provide the full picture
- Lifecycle management of MCP processes started by plugins is a bit kludgy at best
The biggest takeaway is how much of a difference it made in claude performance when I switched to background (fire and forget) hooks and removed all other plugins. It's easy to forget how many claude plugins I've installed and how they effect performance.
The Agents Observe plugin uses docker to start the API and dashboard service. This is a pattern I'd love to see used more often for security (think Axios hack) reasons. The tricky bit was handling process management across multiple claude instances - the solution was to have the server track active connections then auto shut itself down when not in use. Then the plugin spins it back up when a new session is started.
This tool has been incredibly useful for my own daily workflow. Enjoy!", "url": "https://github.com/simple10/agents-observe", "upvotes": 77, "comments": 28, "sub": "hackernews", "signal": 24.4, "hits": [ "claude code" ] }, { "src": "github", "id": "1247987146", "title": "JasonColapietro/suede-creator-skills", "body": "Open-source Agent Skills for Claude Code and Codex: ship-DAG orchestration, A-F code review, AI evals, CI gates, design, copy, SEO/AEO/GEO, Instagram growth, app shipping, creator rights, and consumer recovery. agent-orchestration agent-skill agent-skills ai-agents ai-coding anthropic claude-code claude-code-plugin claude-code-skills claude-skills code-review codex developer-tools evals llm-evaluation mcp-server multi-agent openai-codex plugin-marketplace seo", "url": "https://github.com/JasonColapietro/suede-creator-skills", "upvotes": 133, "comments": 5, "sub": "github", "signal": 23.6, "hits": [ "claude code", "evals" ] }, { "src": "hackernews", "id": "44913696", "title": "Q Evaluation Harness: open-source evals for LLMs on q/kdb+", "body": "Author here. We built an open-source evaluation harness for LLMs on q/kdb+. It includes: a q-HumanEval set (164 tasks), reproducible Pass@k scoring, and a public leaderboard.
Why this matters: top models score ~96% Pass@1 on Python HumanEval, but best Pass@1 on q-HumanEval is ~43.4%, so there’s clear room for improvement. Early runs show large gains with multiple attempts (e.g., Grok 4: 43.37% → 74.32% Pass@10).
We’d love your help with two things:\n1. Try it out & add your models to the leaderboard.\n2. Contribute new datasets, and provide feedback on any potential improvements.
• GitHub: https://github.com/KxSystems/q-evaluation-harness/tree/main\n• Launch write-up: https://medium.com/kx-systems/introducing-q-evaluation-harne...\n• Leaderboard: https://github.com/KxSystems/q-evaluation-harness/blob/main/...\n• License: MIT
Happy to answer questions and take PRs.", "url": "https://github.com/KxSystems/q-evaluation-harness", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 23.1, "hits": [ "evaluation harness", "evals" ] }, { "src": "hackernews", "id": "48832797", "title": "Show HN: Abralo – Free, easy way to run several Claude Code agents in one window", "body": "Hi guys,
I've been using Claude Code for almost everything lately. Have given one an email account so it can research business leads, draft emails, fact-check them and clear them with me before sending (works really well by the way). I also tend to have a few Claude Code agents running at any one time for coding.
I used to create a split terminal to manage them from there, but found working in the terminal all day pretty depressing and, more importantly, found it hard to follow Claude Code's process and see which agents needed my immediate attention.
I tried Anthropic's VS Code Claude Code extension and it had a great UI (more info on Claude Code's process and easier to read), but it crashed my PC when I ran more than 3 and I couldn't watch multiple agents in parallel (had to constantly switch between them).
So I built a lightweight Tauri desktop app which lets you run multiple Claude Code agents in one window alongside each other. It's easier to read the output and see which agents need your attention than a terminal.
Have been using this all day everyday instead of an IDE and have obsessed over every detail to make sure it's easy-to-use, but also lightweight and fast (so you can manage multiple agents without your PC crashing).
There are some nice features like better usage alerts for when you're going to hit your 5-hour and weekly limits (with sparklines to show when usage peaked, and which agents are the most token-intensive).
It's free to use (you just need to log in with your existing Claude Code account) for up to 4 agents simultaneously. This app doesn't store your Claude Code account details and doesn't store any of your interactions with Claude Code. They remain between you and Anthropic. It's compatible with Windows, MacOS and 64-bit Linux.
Would really appreciate any feedback, so if you have any thoughts, issues or suggestions please let me know.
Thanks,\nChris", "url": "https://abralo.com/", "upvotes": 37, "comments": 31, "sub": "hackernews", "signal": 23.1, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "45541794", "title": "AI receptionist that answers real phone calls", "body": "We’re building an AI receptionist that answers real phone calls, captures leads, books appointments, and sends 5‑minute follow‑ups. Our first niche is wedding venues. I’m one of the founders.
What might be interesting to HN:
Conversation loop: telephony → streaming ASR → LLM tools → calendar/email → TTS, with turn‑taking and barge‑in control.\nCalendar booking: buffer‑time logic + double‑booking prevention; we expose a minimal function API for “OfferSlots/BookSlot/Confirm.”\nMulti‑channel capture: unify phone, email, and form leads into one record with transcript + fields (name, date, guest count, budget).\nSpam filtering: block patterns (e.g., 1‑800s / robocalls) before they hit staff; safe pass‑through rules for VIPs.\nEvaluation harness: scripted call scenarios (availability, pricing, policy) → check for grounding (answers must be in your docs) → score for correctness, safety, and escalation timing.
What didn’t work:
Over‑eager answers before knowledge ingestion; we now hard‑gate answers on verified sources and otherwise take a message or escalate.\nElevenlabs; Latency is way too much to build a human like experience. \nConfusion on edge cases (“What’s your cancellation policy if…”). We added doc‑first retrieval + fallback to “collect info + route.”
Numbers so far (early, only 6 customers and improving):
Target answer time: sub‑second pickup; 5‑minute first reply on email.\nReduction in missed calls and faster tour scheduling are the main wins; happy to share more once data matures.
Privacy/ethics:
Customer content is not used to train our models.\nClear consent and recording policies; PII is encrypted at rest and in transit.\nWhat I’d love feedback on:
Better offline evaluation for voice agents (beyond happy‑path scripts).\nTurn‑taking and barge‑in strategies you’ve found to work well.\nFailure‑mode handling you’d want before trusting an AI with calls.
Link: https://mikla.ai", "url": "https://news.ycombinator.com/item?id=45541794", "upvotes": 1, "comments": 4, "sub": "hackernews", "signal": 22.9, "hits": [ "evaluation harness", "retrieval" ] }, { "src": "github", "id": "1193350097", "title": "Muizzkolapo/agent-actions", "body": "Declarative framework for orchestrating multi-model Agentic pipelines with context engineering and quality gates. ai-agents anthropic context-engineering-framework llm orchestration prompt-engineering prompt-engineering-tool yaml", "url": "https://github.com/Muizzkolapo/agent-actions", "upvotes": 8, "comments": 37, "sub": "github", "signal": 22.8, "hits": [ "context engineering" ] }, { "src": "github", "id": "1303449802", "title": "Ryanaldo34/tacklr", "body": "The opinionated framework for building enterprise agent operating systems. Deterministic execution runtime, tool gating & security controls, knowledge building & retrieval, secure code execution, observability, and efficient context engineering all in one agentic-ai agents ai ai-agents ai-tools artificial-intelligence go golang harness harness-engineering harness-framework llm", "url": "https://github.com/Ryanaldo34/tacklr", "upvotes": 6, "comments": 10, "sub": "github", "signal": 22.3, "hits": [ "context engineering", "retrieval" ] }, { "src": "hackernews", "id": "47859244", "title": "Show HN: ModelX – Prediction Exchange for LLMs", "body": "Hey all!
I work in quantitative trading, and so far our team’s use of LLMs has barely gone beyond coding. I wanted to find out whether they could contribute to actual trading decisions, and the first step felt like building an evaluation harness.\nModelX is my attempt at that. It’s a prediction exchange where LLMs trade derivative contracts that settle to real-world numbers using fake money.
Market making and market taking require different reasoning processes, so I split the benchmark into two roles: Market Makers and Hedge Funds. MMs post sealed two-sided quotes, while HFs see the residual orderbook and send market orders.
Most traditional markets operate in continuous time, which means speed often determines the winners. I didn’t want to benchmark inference speed, so orders are batched into 30-minute sealed-auction cycles. As long as a model submits before the cycle closes, its orders are matched simultaneously with all other models'.
Each cycle, models see relevant news headlines, recent trades, the current orderbook, and their own inventory. They decide, the engine matches everyone simultaneously, and the loop repeats until I manually settle the market.
I've only been running a single market with free models for the past day or two, but I've already noticed that the models are poor at keeping consistent positional views. The HFs are consistently losing, not necessarily because they entered bad positions, but instead because they continuously hack out of their own positions, giving up the spread to the MMs. I've deliberately kept the prompts minimal so as not to hand-hold the models.
Running more markets and testing more capable models would be some obvious next steps.
Please let me know your thoughts, or if you have any suggestions!", "url": "https://model-x.up.railway.app/", "upvotes": 4, "comments": 0, "sub": "hackernews", "signal": 22.2, "hits": [ "evaluation harness", "benchmark" ] }, { "src": "hackernews", "id": "48709606", "title": "Show HN: Caliper – pass@k reliability testing for Claude Code and Codex skills", "body": "Skills for Claude Code and Codex are hard to test. What I mean by hard is that there's no standard way to do it. You evaluate the skill once on something, it looks like it works. You publish it. Then the new super model releases (GLM 5.2 anyone?), it will quietly break for some part, and you won't find out until your users complain.
I also faced the same problem, so I tried to build something lightweight to stop doing that. Caliper.
It's a local and lightweight harness that runs a skill k times in isolated environments and gives you a pass@k score (How much times it succeeded in these k times). As a non-deterministic technology, you can't just say "it worked once". You need to answer how much it passed in k times.
You define success in a YAML spec. I picked YAML to keep a schema and make it still readable for a human. You either use a LLM judge, a Python assertion, or both:
Here's an simple evaluation example with a JSON extraction, so you write this in a YAML file:
tasks:\n - name: Extracts action items as clean JSON\n prompt: "Read /tmp/transcript.txt and write the\n action items to /tmp/actions.json."\n expect: "A valid JSON array where every item has\n owner, task, due. No markdown fences."\n assert: |\n import json\n items = json.load(open("/tmp/actions.json"))\n assert isinstance(items, list)\n assert all({"owner","task","due"} <= i.keys()\n for i in items)\ncaliper run extract-actions.eval.yaml --k 5 --baseline
What's cool about the --baseline flag is that it will re-runs everything without the skill, so you can see whether the skill is doing the work or the base agent was going to pass anyway:
ID Task k(5) pass@k\n task-1 Extracts action items as JSON 5/5 100% PASS\n With skill 100%\n No skill 60%\n Delta +40%\nI also created two skills you can get started right away with your favorite harness, e.g. Claude Code, Codex or Pi:
- evaluate-skill: run and manage evals without leaving your workflow
- grill-skill: reads your SKILL.md, interviews you about what "good" looks like, writes a 3-task spec (happy path, edge case, adversarial), and runs it
You can install the skill with the command: npx skills@latest add edonadei/caliper
I for now support claude-code, codex, pi, claude-api, openai-api. You can run the agent and the judge as separate backends, so you can run a skill on one and judge with another.
GitHub: https://github.com/edonadei/caliper\nPyPI: https://pypi.org/project/caliper-eval/
Of course, it's a first step. I think the autorater layer can be vastly improved, more handholding to create and iterate on evaluation specs, supporting more harness, why not including this layer into a self-improvement bigger system?
If you're also building agentic evaluations, I'm genuinely interested to hear how you are handling that.", "url": "https://github.com/edonadei/caliper", "upvotes": 3, "comments": 3, "sub": "hackernews", "signal": 21.8, "hits": [ "claude code", "evals" ] }, { "src": "hackernews", "id": "43822659", "title": "Show HN: Web-eval-agent – Let the coding agent debug itself", "body": "Hey HN! We’ve been building an MCP server to help AI-assisted web app developers by using browser agents to test whether changes made by an AI inside an editor actually work. We've been testing it on scenarios like verifying new flows in a UI, or checking that sending a chat request triggers a response. The idea is to let your coding agent both code and evaluate if what it did was correct. Here’s a short demo with Cursor: https://www.youtube.com/watch?v=_AoQK-bwR0w
When building apps, we found the hardest part of AI-assisted coding isn’t the coding—it’s tedious point-and-click testing to see if things work. We got tired of this loop: open the app, click through flows, stare at the network tab, copy console errors to the editor, repeat. It felt obvious this should be AI-assisted too. If you can vibe-code, you should be able to vibe-test!
Some agents like Cline and Windsurf have browser integrations, but Cline’s (via Anthropic Computer Use) felt slow and only reported console logs, and Windsurf’s didn’t work reliably yet. We got so tired of manually testing that we decided to fix it.
Our MCP server sits between your IDE agent (Cursor/Windsurf/Cline/Continue) and a Playwright-powered browser-use agent. It spins up the browser, navigates your app per instructions from the IDE agent, and sends back steps, console events, and network events so the IDE agent can assess the app’s state.
We proxy Browser-use’s original Claude calls and swap in Gemini Flash 2.0, cutting latency from ~8s → ~3s per step. We also cap console/network logs at 10,000 characters to stay within context limits, and filter out irrelevant logs (e.g., noisy XHR requests).
At the end, the browser agent outputs a summary like:
Web Evaluation Report for http://localhost:5173 \n Task: delete an API key and evaluate UX\n Steps: Home → Login → API Keys → Create Key → Delete Key\n Flow tested successfully; UX had problems X, Y, Z...\n Console (8)... Network (13)... Timeline of events (57) …\nTry it in Cursor / Cline / Windsurf / Claude Desktop: (macOS/Linux):
curl -LSf https://operative.sh/install.sh -o install.sh\n less -N install.sh # inspect if you’d like\n bash install.sh # installs uv + jq + Playwright + server\n # then in Cursor/Cline/Windsurf/Continue: craft a prompt using the web_eval_agent tool\nWhat we want to do next: pause/go for OAuth screens; save/load browser auth states; Playwright step recording for automated test creation and regression test creation; supporting Loveable / v0 / Bolt.new sites by offering a web version.
We’d love to hear your feedback, especially if you’ve experienced the pain of having to manually test changes happening in your web apps after making changes from inside your IDE, or if you’ve tried any alternative MCP tools for this that have worked well.
Try it out if you feel it’d be helpful for your workflow: https://github.com/Operative-Sh/web-eval-agent. (note: the server hits our operative.sh proxy to cover Gemini tokens. The MCP server itself is OSS; Anthropic base-URL support is coming soon. Free tier included; heavy users can grab the $10 plan to offset our model bill.)
Let us know what you think! Thanks for reading!", "url": "https://github.com/Operative-Sh/web-eval-agent", "upvotes": 84, "comments": 12, "sub": "hackernews", "signal": 21.6, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "44309393", "title": "Show HN: Free local security checks for AI coding in VSCode, Cursor and Windsurf", "body": "Hi HN!
We just launched Codacy Guardrails, an IDE extension with a CLI for code analysis and MCP server that enforces security & quality rules on AI-generated code in real-time. It hooks into AI coding assistants (like VS Code Agent Mode, Cursor, Windsurf), silently scanning and fixing AI-suggested code that has vulnerabilities or violates your coding standards, while the code it’s being generated.
We built this because coding agents can be a double-edged sword. They do boost productivity, but can easily introduce insecure or non-compliant code. One recent research team at NYU found that 40% of Copilot’s outputs were buggy or exploitable [1]. Other surveys mention that people are spending more time debugging AI-generated code [2].
That's why we created “guardrails” to catch security problems early.
Codacy Guardrails uses a collection of open-source static analyzers (like Semgrep and Trivy) to scan the AI’s output against 2000+ rules. We currently support JavaScript/TypeScript, Python, and Java, focusing on things like OWASP Top 10 vulns, hardcoded secrets, dependency checks, code complexity and styling violations, and you can customize the rules to match your project’s needs. We're not using any AI models, it's “classic” static code analysis working alongside your AI assistant.
Here’s a quick demo: https://youtu.be/pB02u0ntQpM
The extension is free for all developers. (We do have paid plans for teams to apply rules centrally, but that’s not needed to use the extension and local code analysis with agents.)
Setup is pretty straightforward: Install the extension and enable Codacy’s CLI and MCP Server from the sidebar.
We’re eager to hear what the HN community thinks! Does this approach sound useful in your AI coding workflow? Have you encountered security issues from AI-generated code?
We hope Codacy Guardrails can make AI-assisted development a bit safer and more trustworthy. Thanks for reading!
Get extension: https://www.codacy.com/get-ide-extension\nDocs: https://docs.codacy.com/codacy-guardrails/codacy-guardrails-...
Sources\n[1]: NYU Research: https://www.researchgate.net/publication/388193053_Asleep_at...\n[2]: https://devops.com/survey-ai-tools-are-increasing-amount-of-...", "url": "https://news.ycombinator.com/item?id=44309393", "upvotes": 43, "comments": 22, "sub": "hackernews", "signal": 21.6, "hits": [ "coding agent" ] }, { "src": "github", "id": "1077825655", "title": "bonigarcia/context-engineering", "body": "Context Engineering: Build Consistent, Accurate, Predictable AI Systems agent-skills agentic-ai context-engineering generative-ai llm mcp mcp-server memory-management multi-agent-systems prompting rag spec-driven-development", "url": "https://github.com/bonigarcia/context-engineering", "upvotes": 132, "comments": 0, "sub": "github", "signal": 21.6, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "44275368", "title": "Show HN: Vishu – Model Context Protocol (MCP) Suite", "body": "I'm thrilled to introduce Vishu (MCP) Suite, an open-source application I've been developing that takes a novel approach to vulnerability assessment and reporting by deeply integrating Large Language Models (LLMs) into its core workflow.\nWhat's the Big Idea?\nInstead of just using LLMs for summarization at the end, Vishu (MCP) Suite employs them as a central reasoning engine throughout the assessment process. This is managed by a robust Model Contet Protocol (MCP) agent scaffolding designed for complex task execution.\nCore Capabilities & How LLMs Fit In:\n1. Intelligent Workflow Orchestration: The LLM, guided by the MCP, can:\n2. • Plan and Strategize: Using a SequentialThinkingPlanner tool, the LLM breaks down high-level goals (e.g., "assess example.com for web vulnerabilities") into a series of logical thought steps. It can even revise its plan based on incoming data!\n• Dynamic Tool Selection & Execution: Based on its plan, the LLM chooses and executes appropriate tools from a growing arsenal. Current tools include:\n• ◇ Port Scanning (PortScanner)\n◇ Subdomain Enumeration (SubDomainEnumerator)\n◇ DNS Enumeration (DnsEnumerator)\n◇ Web Content Fetching (GetWebPages, SiteMapAndAnalyze)\n◇ Web Searches for general info and CVEs (WebSearch, WebSearch4CVEs)\n◇ Data Ingestion & Querying from a vector DB (IngestText2DB, QueryVectorDB, QueryReconData, ProcessAndIngestDocumentation)\n◇ Comprehensive PDF Report Generation from findings (FetchDomainDataForReport, RetrievePaginatedDataSection, CreatePDFReportWithSummaries)
• Contextual Result Analysis: The LLM receives tool outputs and uses them to inform its next steps, reflecting on progress and adapting as needed. The REFLECTION_THRESHOLD in the client ensures it periodically reviews its overall strategy.
• Unique MCP Agent Scaffolding & SSE Framework:\n• ◇ The MCP-Agent scaffolding (ReConClient.py): This isn't just a script runner. The MCP-scaffolding manages "plans" (assessment tasks), maintains conversation history with the LLM for each plan, handles tool execution (including caching results), and manages the LLM's thought process. It's built to be robust, with features like retry logic for tool calls and LLM invocations.\n◇ Server-Sent Events (SSE) for Real-Time Interaction (Rizzler.py, mcp_client_gui.py): The backend (FastAPI based) communicates with the client (including a Dear PyGui interface) using SSE. This allows for:\n◇ ▪ Live Streaming of Tool Outputs: Watch tools like port scanners or site mappers send back data in real-time.\n▪ Dynamic Updates: The GUI reflects the agent's status, new plans, and tool logs as they happen.\n▪ Flexibility & Extensibility: The SSE framework makes it easier to integrate new streaming or long-running tools and have their progress reflected immediately. The tool registration in Rizzler.py (@mcpServer.tool()) is designed for easy extension.
We Need Your Help to Make It Even Better!\nThis is an ongoing project, and I believe it has a lot of potential. I'd love for the community to get involved:\n◇ Try it Out: Clone the repo, set it up (you'll need a GOOGLE_API_KEY and potentially a local SearXNG instance, etc. – see .env patterns), and run some assessments!\n◇ ▪ GitHub Repo: https://github.com/seyrup1987/ReconRizzler-Alpha", "url": "https://news.ycombinator.com/item?id=44275368", "upvotes": 2, "comments": 2, "sub": "hackernews", "signal": 21.5, "hits": [ "mcp agent", "vector" ] }, { "src": "github", "id": "1199688991", "title": "Adam-S-Daniel/GHA-bench", "body": "GHA-bench is a benchmark and a set of evals for how well different coding agents author and test GitHub Actions using different languages. ", "url": "https://github.com/Adam-S-Daniel/GHA-bench", "upvotes": 0, "comments": 2, "sub": "github", "signal": 21.4, "hits": [ "coding agent", "evals", "benchmark" ] }, { "src": "hackernews", "id": "44139226", "title": "Productivity apps won't disappear, just the need to open them will", "body": "There’s a quiet but profound shift happening in how we interact with software. Agent frameworks like mcp-agent, Superblocks, and Lovable are starting to erode the need for traditional UI-based productivity tools—not by replacing them, but by automating around them.
Instead of opening Notion, Figma, or Asana to perform a task, developers are chaining agent workflows that handle it directly:
• Need a sprint plan? The agent assembles it using past tasks and meeting notes.\n• Need a report? The agent pulls data from Airtable and emails a summary.\n• Need a brainstorm canvas? The agent generates one from context.
These aren’t generic assistants. They’re agents that call tools directly (via APIs or Model Context Protocol), apply org-specific logic, and return structured outputs. No GUI. No tabs. Just outcome.
The architecture shift looks like this:
• Apps → backends\n• Agents → interface layer\n• Human input → intent, not navigation
In this model, tools like Notion become data stores. Figma becomes a renderer. Jira becomes a structured event log. The real “productivity platform” is an orchestrated mesh of tool calls, policies, and workflows—interfaced through a single prompt.
We’ve been here before. CLI > GUI > SaaS > API-first tooling. Now: API + LLM = agents. It’s not perfect yet, but it’s real—and accelerating.
The exciting part isn’t speed or efficiency (though both are improving). It’s that the cognitive load of learning and navigating software disappears. You no longer need to know how to use 10 tools, you just need to know what you want.
Feels like the early days of cloud. Invisible infrastructure, powered by intent.
Would be curious how others are using agents in production or where this abstraction breaks down.
https://x.com/zahiremami/status/1928527937705226368", "url": "https://news.ycombinator.com/item?id=44139226", "upvotes": 4, "comments": 5, "sub": "hackernews", "signal": 21.2, "hits": [ "agent workflow" ] }, { "src": "hackernews", "id": "43426164", "title": "Show HN: AgentKit – JavaScript Alternative to OpenAI Agents SDK with Native MCP", "body": "Hi HN! I’m Tony, co-founder of Inngest. I wanted to share AgentKit, our Typescript multi-agent library we’ve been cooking and testing with some early users in prod for months.
Although OpenAI’s Agents SDK has been launched since, we think an Agent framework should offer more deterministic and flexible routing, work with multiple model providers, embrace MCP (for rich tooling), and support the unstoppable and growing community of TypeScript AI developers by enabling a smooth transition to production use cases.
This is why we are building AgentKit, and we’re really excited about it for a few reasons:
Firstly, it’s simple. We embrace KISS principles brought by Anthropic and HuggingFace by allowing you to gradually add autonomy to your AgentKit program using primitives:
- Agents: LLM calls that can be combined with prompts, tools, and MCP native support.
- Networks: a simple way to get Agents to collaborate with a shared State, including handoff.
- State: combines conversation history with a fully typed state machine, used in routing.
- Routers: where the autonomy lives, from code-based to LLM-based (ex: ReAct) orchestration
The routers are where the magic happens, and allow you to build deterministic, reliable, testable agents.
AgentKit routing works as follows: the network calls itself in a loop, inspecting the State to determine which agents to call next using a router. The returned agent runs, then optionally updates state data using its tools. On the next loop, the network inspects state data and conversation history, and determines which new agent to run.
This fully typed state machine routing allows you to deterministically build agents using any of the effective agent patterns — which means your code is easy to read, edit, understand, and debug.
This also makes handoff incredibly easy: you define when agents should hand off to each other using regular code and state (or by calling an LLM in the router for AI-based routing). This is similar to the OpenAI Agents SDK but easier to manage, plan, and build.
Then comes the local development and moving to production capabilities.
AgentKit is compatible with Inngest’s tooling, meaning that you can test agents using Inngest’s local DevServer, which provides traces, inputs, outputs, replay, tool, and MCP inputs and outputs, and (soon) a step-over debugger so that you can easily understand and visually see what's happening in the agent loop.
In production, you can also optionally combine AgentKit with Inngest for fault-tolerant execution. Each agent’s LLM call is wrapped in a step, and tools can use multiple steps to incorporate things like human-in-the-loop. This gives you native orchestration, observability, and out-of-the-box scale.
You will find the documentation as an example of an AgentKit SWE-bench and multiple Coding Agent examples.
It’s fully open-source under the Apache 2 license.
If you want to get started:
- npm: npm i @inngest/agent-kit
- GitHub: https://github.com/inngest/agent-kit
- Docs: https://agentkit.inngest.com/overview
We’re excited to finally launch AgentKit; let us know what you think!", "url": "https://github.com/inngest/agent-kit", "upvotes": 64, "comments": 15, "sub": "hackernews", "signal": 21.2, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "47945185", "title": "Why Codex works better than Claude Code for my production monolith", "body": "Over the last year I mostly used Codex, but during the last month I tried Claude Code with Opus 4.6 and 4.7. These are my notes.
This is not a benchmark. It is just my experience from daily use on one production codebase. For some medium-complexity tasks, I also ran both tools with the same prompts, but I did not try to make this a controlled evaluation.
TL;DR: for my production Python monolith, I still prefer Codex.
The codebase is a many-years-old Python backend. It has several architectural layers from different periods: a newer experimental DDD-ish style, older but still well-structured legacy code, and very old fragile spaghetti code.
We usually do not rewrite old parts unless we have to. The preferred strategy is to leave them alone until they are naturally replaced or removed. This is not a simple CRUD web server. It is a complex, sometimes overcomplicated, application with many A/B tests and very specific business logic in many corners.
Why I prefer Codex for this codebase:
1. Codex follows harness-engineering principles much better for me. See: https://openai.com/index/harness-engineering/\nClaude does not reliably follow this workflow unless my AGENTS.md contains very explicit short instructions, such as: “Read exec_plan.md and follow it.”
2. Claude more often creates new tools instead of first searching the codebase for existing ones.\nIn this kind of codebase, reusing existing project-specific tools and patterns matters a lot.
3. Claude more often reads too little code or documentation before choosing where to put new functionality.\nI frequently had to go through several correction rounds in the same task:\n“Put this functionality in module A instead, not in the controller. That is the right place.”\n“Do not construct the response object using the statuses you sent in the request. The API already returns the updated object — use that response, include it in the result, and validate that its state matches what we expect.”\n“No, validate it in the same module that owns this boundary.”\nThis kind of back-and-forth became tiring. Codex seems to have a better planning mode for this type of work. It more often notices missing context in my prompt and asks clarifying questions before making architectural changes.
4. I migrated through several Codex/GPT model versions during this period because new versions were released while I was testing. I have not tested GPT-5.5 on UI-heavy work yet.\nHowever, Opus 4.6 was much better for frontend work than Codex 5.3 and GPT-5.4 in my experience. For UI tasks, I currently prefer Claude.
Skills and MCP:\nI use only one shared skill for both LLMs: commands to start and stop the Docker Compose environment and run tests inside it.", "url": "https://news.ycombinator.com/item?id=47945185", "upvotes": 14, "comments": 2, "sub": "hackernews", "signal": 21.1, "hits": [ "claude code", "benchmark" ] }, { "src": "hackernews", "id": "47719403", "title": "Show HN: Skilldeck – Desktop app to manage AI agent skill files across tools", "body": "Skill files (.claude/skills/, .cursor/rules/*.mdc, \nAGENTS.md, .windsurfrules) are becoming a core part of \nAI-assisted development workflows. The problem: they \nscatter across projects, diverge silently, and every new \nrepo means rebuilding behavioral config from scratch. Each \ntool uses a different format and location.
Skilldeck keeps one local library and deploys to any tool \nin the correct format automatically. Ten built-in target \nprofiles cover Claude Code, Cursor, Copilot, Windsurf, \nCodex, and more. Drift detection shows when a deployed \nskill has fallen out of sync with the library version. \nBidirectional sync lets you pull improvements back from a \nproject into the library.
The interesting part technically: the entire app was built \nby Claude Code using a harness engineering methodology — \na ground truth JSON file, Playwright E2E verification \ntests, a regression gate based on a surfaces map, and a \nfeature intake protocol. 31 features across multiple \nautonomous sessions with no manual application code. I \nwrote two articles about the harness approach if that side \nis interesting.
No cloud, no backend, local filesystem only. \nWindows/macOS/Linux. Open source.
github.com/ali-erfan-dev/skilldeck", "url": "https://github.com/ali-erfan-dev/skilldeck", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 21.1, "hits": [ "claude code", "tool use" ] }, { "src": "hackernews", "id": "46586875", "title": "Show HN: Notebooklm-Py – Unofficial Python API for Google NotebookLM", "body": "Hi HN,\nI’ve been using NotebookLM heavily, but the manual "drag-and-drop" workflow was a bottleneck. I wanted to build automated pipelines (like auto-generating podcasts from a folder of PDFs), but the lack of an official API made this impossible.\nThe Solution: By mapping the internal RPC endpoints used by the web frontend, I built a native Python client that interacts directly with the backend. This bypasses the overhead and brittleness of browser automation tools like Selenium.\nDemo:\nWatch Claude Code use the CLI to automate a workflow in the terminal: https://asciinema.org/a/767284\nWhat you can do with it:\nDeep Research & Content Automation: Automate the entire research loop. You can programmatically create a new notebook, import deep research on specific topics, and then trigger the generation of both an Audio Overview (podcast) and a Slide Deck, downloading the final assets in one go.\nRAG Pipelines: Use NotebookLM as a grounded backend for agents (query a notebook -> get cited answers).\nCLI for Humans & LLMs: The package includes a comprehensive CLI designed for both end-users and agents. It even features a command to auto-install itself as a "Skill" for Claude Code, letting you control NotebookLM via natural language in your terminal.\nStability & Testing:\nUnofficial APIs are risky. To mitigate silent breakage, I treated this package like a production product. The repo includes a triple-layer test suite (Unit, Integration, and Daily E2E Cron tests). If Google changes their definitions, my CI fails immediately, and we’ll know before users do.\nAuth Note:\nThe library runs on pure Python (ideal for headless servers), but it requires a valid session cookie to start. The CLI makes this easy: just run notebooklm-py login to perform the one-time extraction (it briefly opens a browser via Playwright). Once you have the token, you can deploy it anywhere without a browser.\nRepo:\nhttps://github.com/teng-lin/notebooklm-py\nHappy to answer questions!", "url": "https://github.com/teng-lin/notebooklm-py", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 21.1, "hits": [ "claude code", "rag pipeline" ] }, { "src": "hackernews", "id": "43763967", "title": "Show HN: Rowboat – Open-source IDE for multi-agent systems", "body": "Hi HN! We’re Arjun, Ramnique, and Akhilesh, and we are building Rowboat (https://www.rowboatlabs.com/), an AI-assisted IDE for building and managing multi-agent systems. You start with a single agent, then scale up to teams of agents that work together, use MCP tools, and improve over time - all through a chat-based copilot.
Our repo is https://github.com/rowboatlabs/rowboat, docs are at https://docs.rowboatlabs.com/, and there’s a demo video here: https://youtu.be/YRTCw9UHRbU
It’s becoming clear that real-world agentic systems work best when multiple agents collaborate, rather than having one agent attempt to do everything. This isn’t too surprising - it’s a bit like how good code consists of multiple functions that each do one thing, rather than cramming everything into one function.
For example, a travel assistant works best when different agents handle specialized tasks: one agent finds the best flights, another optimizes hotel selections, and a third organizes the itinerary. This modular approach makes the system easier to manage, debug, and improve over time.
OpenAI’s Agents SDK provides a neat Python library to support this, but building reliable agentic systems requires constant iterations and tweaking - e.g. updating agent instructions (which can quickly get as complex as actual code), connecting tools, and testing the system and incorporating feedback. Rowboat is an AI IDE to do all this. Rowboat is to AI agents what Cursor is to code.
We’ve taken a code-like approach to agent instructions (prompts). There are special keywords to directly reference other agents, tools or prompts - which are highlighted in the UI. The copilot is the best way to create and edit these instructions - each change comes with a code-style diff.
You can give agents access to tools by integrating any MCP server or connecting your own functions through a webhook. You can instruct the agents on when to use specific tools via ‘@mentions’ in the agent instruction. To enable quick testing, we added a way to mock tool responses using LLM calls.
Rowboat playground lets you test and debug the assistants as you build them. You can see agent transfers, tool invocations and tool responses in real-time. The copilot has the context of the chat, and can improve the agent instructions based on feedback. For example, you could say ‘The agent shouldn’t have done x here. Fix this’ and the copilot can go and make this fix.
You can integrate agentic systems built in Rowboat into your application via the HTTP API or the Python SDK (‘pip install rowboat’). For example, you can build user-facing chatbots, enterprise workflows and employee assistants using Rowboat.
We’ve been working with LLMs since GPT-1 launched in 2018. Most recently, we built Coinbase’s support chatbot after our last AI startup was acquired by them.
Rowboat is Apache 2.0 licensed, giving you full freedom to self-host, modify, or extend it however you like.
We’re excited to share Rowboat with everyone here. We’d love to hear your thoughts!", "url": "https://github.com/rowboatlabs/rowboat", "upvotes": 161, "comments": 51, "sub": "hackernews", "signal": 21, "hits": [] }, { "src": "hackernews", "id": "47263036", "title": "Show HN: Jido 2.0, Elixir Agent Framework", "body": "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\n- Comprehensive multi-agent support across distributed BEAM processes with Supervision\n- Multiple reasoning strategies including ReAct, Chain of Thought, Tree of Thought, and more\n- Advanced workflow capabilities\n- Durability through a robust Storage and Persistence layer\n- Agentic Memory\n- MCP and Sensors to interface with external services\n- 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!", "url": "https://jido.run/blog/jido-2-0-is-here", "upvotes": 323, "comments": 65, "sub": "hackernews", "signal": 21, "hits": [] }, { "src": "hackernews", "id": "43692476", "title": "Launch HN: mrge.io (YC X25) – Cursor for code review", "body": "Hey HN, we’re building mrge (https://www.mrge.io/home), an AI code review platform to help teams merge code faster with fewer bugs. Our early users include Better Auth, Cal.com, and n8n—teams that handle a lot of PRs every day.
Here’s a demo video: https://www.youtube.com/watch?v=pglEoiv0BgY
We (Allis and Paul) are engineers who faced this problem when we worked together at our last startup. Code review quickly became our biggest bottleneck—especially as we started using AI to code more. We had more PRs to review, subtle AI-written bugs slipped through unnoticed, and we (humans) increasingly found ourselves rubber-stamping PRs without deeply understanding the changes.
We’re building mrge to help solve that. Here’s how it works:
1. Connect your GitHub repo via our Github app in two clicks (and optionally download our desktop app). Gitlab support is on the roadmap!
2. AI Review: When you open a PR, our AI reviews your changes directly in an ephemeral and secure container. It has context into not just that PR, but your whole codebase, so it can pick up patterns and leave comments directly on changed lines. Once the review is done, the sandbox is torn down and your code deleted – we don’t store it for obvious reasons.
3. Human-friendly review workflow: Jump into our web app (it’s like Linear but for PRs). Changes are grouped logically (not alphabetically), with important diffs highlighted, visualized, and ready for faster human review.
The AI reviewer works a bit like Cursor in the sense that it navigates your codebase using the same tools a developer would—like jumping to definitions or grepping through code.
But a big challenge was that, unlike Cursor, mrge doesn’t run in your local IDE or editor. We had to recreate something similar entirely in the cloud.
Whenever you open a PR, mrge clones your repository and checks out your branch in a secure and isolated temporary sandbox. We provision this sandbox with shell access and a Language Server Protocol (LSP) server. The AI reviewer then reviews your code, navigating the codebase exactly as a human reviewer would—using shell commands and common editor features like "go to definition" or "find references". When the review finishes, we immediately tear down the sandbox and delete the code—we don’t want to permanently store it for obvious reasons.
We know cloud-based review isn't for everyone, especially if security or compliance requires local deployments. But a cloud approach lets us run SOTA AI models without local GPU setups, and provide a consistent, single AI review per PR for an entire team.
The platform itself focuses entirely on making human code reviews easier. A big inspiration came from productivity-focused apps like Linear or Superhuman, products that show just how much thoughtful design can impact everyday workflows. We wanted to bring that same feeling into code review.
That’s one reason we built a desktop app. It allowed us to deliver a more polished experience, complete with keyboard shortcuts and a snappy interface.
Beyond performance, the main thing we care about is making it easier for humans to read and understand code. For example, traditional review tools sort changed files alphabetically—which forces reviewers to figure out the order in which they should review changes. In mrge, files are automatically grouped and ordered based on logical connections, letting reviewers immediately jump in.
We think the future of coding isn’t about AI replacing humans—it’s about giving us better tools to quickly understand high-level changes, abstracting more and more of the code itself. As code volume continues to increase, this shift is going to become increasingly important.
You can sign up now (https://www.mrge.io/home). mrge is currently free while we're still early. Our plan for later is to charge closed-source projects on a per-seat basis, and to continue giving mrge away for free to open source ones.
We’re very actively building and would love your honest feedback!", "url": "https://news.ycombinator.com/item?id=43692476", "upvotes": 221, "comments": 108, "sub": "hackernews", "signal": 21, "hits": [] }, { "src": "hackernews", "id": "43752176", "title": "Launch HN: Magic Patterns (YC W23) – AI Design and Prototyping for Product Teams", "body": "Alex and Teddy here. We’re launching Magic Patterns (https://www.magicpatterns.com), an AI prototyping tool that helps PMs and designers create functional, interactive designs and websites. There’s a demo video at https://www.youtube.com/watch?v=SK8C_tQBwIU, as well as video walkthroughs of specific examples at https://www.magicpatterns.com/docs/documentation/tutorials/v...
While other tools help with “AI-assisted coding,” we have been quietly focused on “AI-assisted designing.” With Magic Patterns you can visually communicate your idea, get hands on feedback from customers, and test new features.
Teddy and I are best friends and former frontend engineers turned founders. We arrived at Magic Patterns after several pivots—always in the design tooling space, but different products that all struggled to get usage. We started working on Magic Patterns after an internal hackathon. Teddy built a UI library catalog and I messed around with GPT 3.5. We thought it’d be fun to combine the two: an AI component generator. Describe whatever you want, and get back a React component!
That started to take off and we gained users, but it wasn’t developers using the tool. Instead, it was PMs, designers, and leadership who could finally communicate their ideas. They use it to test new ideas quickly, get feedback from customers, and improve communication with internal teams. Also, hobbyists (and programmers who aren’t designers) use us to create designs and UIs that they wouldn’t be able to otherwise.
We use Sonnet 3.5 and 3.7, and leverage a fine-tuned model for fast-applying edits. The most challenging part is determining the most relevant context to feed to the LLM. We attempt to solve this with our click to update feature and by letting users define a brand preset, or default prompt.
Unlike other tools in this space, we’re specifically focused on (1) product teams—we're realtime and collaborative; and (2) frontend only—we don't spin up a database or backend because we aren't solving "idea to fullstack app."
A common workflow is a product manager building an interactive prototype and then passing it off to a designer for more polish or directly to engineers. Many teams are even skipping Figma entirely now, telling us that it feels like an unnecessary middleman. Teams are instead generating clickable prototypes, collaborating directly with stakeholders, and using that as the mockup.
With Magic Patterns, you can: - Collaborate with your team on our infinite canvas; - Match your existing designs by creating reusable components directly; - Brainstorm features and flows. (The latter is what we use it for internally.)
We started as a way to build small, custom components, but now people are one-shotting entire\nwebsites and hosting them with us, or building dashboards that they share internally or in customer demos. People have sold $10k/mo contracts with Magic Patterns designs!
Small business owners—everyone from fishermen to driving instructors to hotel managers—are using us to build their websites and then hosting them with us. Example sites built by Magic Patterns include https://getdealflow.ai/ and https://joinringo.com/. It’s amazing how people who couldn’t have done that before are now able to, and super gratifying to us to be empowering people in this way.
You can get started with our docs here: https://www.magicpatterns.com/docs/documentation/get-started..., and you can try the actual product. Simply go to https://www.magicpatterns.com and prompt for any UI you want.
Today no login is required, just click “Coming from Hackernews?” and you’ll get 5 messages free to try. Once you hit the limit, you’ll then be prompted to login. Plans start at $19/mo for another 100 messages a month (https://www.magicpatterns.com/pricing).
We’re stoked to be sharing with HN today and are open to all feedback!", "url": "https://news.ycombinator.com/item?id=43752176", "upvotes": 185, "comments": 114, "sub": "hackernews", "signal": 21, "hits": [] }, { "src": "hackernews", "id": "41604042", "title": "Show HN: Inngest 1.0 – Open-source durable workflows on every platform", "body": "Hi HN! I’m Tony, one of the co-founders of Inngest (https://inngest.com/)
Inngest is an open-source durable workflow platform that works on any cloud. Durable workflows are stateful, long running step functions written in code, which automatically retry on failure. It abstracts everything about queues, event streams and state for you, letting you focus on code. Some examples of uses: managing stateful AI chained step functions; managing search/rag indexes and data pipelines; integrations and webhooks; billing and payment flows.
Technical details: unlike other solutions, we put lots of effort into designing our SDK’s step.run APIs to make them extremely easy to use — developer experience is the most important thing for us.
We had to design and build our own queueing system to work with multi-tenancy, batching, and debouncing, and we’re iterating on this as we move to FoundationDB. It’s largely all Go in the backend, with a bunch of caching, clickhouse, event streams, and coordination on our behalf. Workers are shared nothing, and run based off of the queue and execution state.
We did a post last year as we iterated on our TS SDK. The product has changed a lot since then and wanted to show the community what’s changed as we reach 1.0:
* Golang, Java, and Python SDKs with cross-language function invocation (across clouds, too)\n\n * Multi-tenant aware flow control (concurrency, throttling, debounce)\n\n * Batching, grouping many events into a single function call\n\n * Much improved dashboard, with tracing and metrics built in\n\n * Advanced recovery tools like function replay, temporary pausing, bulk cancellation (with optional expressions). No more dead letter queues!\n\n * Branch deploys built in, with staging env support out of the box\n\n * Full local testing with production parity\n\nWanted to say thank you to the HN community for feedback so far! Happy Friday :)", "url": "https://www.inngest.com/", "upvotes": 165, "comments": 51, "sub": "hackernews", "signal": 21, "hits": [] }, { "src": "github", "id": "1305080153", "title": "ryanportfolio/tracebench", "body": "Replayable evals for AI coding agents, built from my own developer sessions: does the agent verify claims, own mistakes, and self-correct under pressure? Deterministic, reproducible scoring with every transcript published. agent-evaluation ai-agents benchmark claude-code codex evals llm llm-evaluation python reproducibility", "url": "https://github.com/ryanportfolio/tracebench", "upvotes": 0, "comments": 0, "sub": "github", "signal": 21.0, "hits": [ "coding agent", "evals", "benchmark" ] }, { "src": "hackernews", "id": "42867050", "title": "Show HN: Mcp-Agent – Build effective agents with Model Context Protocol", "body": "Hey HN, I spent my xmas break building an agent framework called mcp-agent [1](https://github.com/lastmile-ai/mcp-agent) for Model Context Protocol [2]. It makes it easy to build AI apps with MCP servers, and implements every pattern from the popular Building Effective Agents blog [3] as well as OpenAI’s Swarm [4]. I’m sharing it early to get community feedback on where to take it from here, and to ask for contributions.
For those who aren’t familiar with MCP, I think of it as a standardized interface to let AI communicate with software via tool calls, resources and prompts.
mcp-agent provides a higher level interface to build apps with MCP. It handles the connection management of MCP servers so you don’t have to. It also implements the Building Effective Agents patterns:\n- Augmented LLM (an LLM with access to one or more MCP servers)\n- Router, Orchestrator-Worker, Evaluator-Optimizer, and more\n- Swarm
The key design principles are composability and reusability – every pattern is an AugmentedLLM itself, so you can chain them into more complex workflows.
Some background: I worked on LSP [5] and language servers at Microsoft, and saw firsthand how standards and protocols can revolutionize developer workflows. Before LSP every IDE had its own esoteric ways of providing language services. LSP changed all that, and arguably made every language server better, since they can focus on improving a single implementation for all clients.
I think AI development is in a similar pre-LSP space right now. There are tons of frameworks [6], every model provider has its own way of handling messages, tool calls, streaming, etc. I really think we need a protocol to standardize these patterns.
Pretty soon every service is going to expose an MCP interface, and mcp-agent is about letting developers orchestrate these services into applications (i.e. build “MCP apps”). This can cover any use of an AI model that needs to interact with the world around it:\n- RAG pipelines and Q&A chatbots\n- Process automation via AI workflows/async tasks\n- Multi-agent orchestration, with human in the loop
The repo contains examples [7] to build RAG agents, streamlit apps and more. There’s a lot left to build, like streaming support, server auth and tighter integration with MCP clients.
But I wanted to share early in the hopes that you can guide me:\n- If you find this useful, please let me know. If it’s useful to you, I will dedicate all my time to improving it.\n- I really welcome contributions. If you want to collaborate, please reach out on github to help take this forward.
I want to help standardize AI development, so developers a few years from now can look back with horror at the pre-MCP days.
[1] - https://github.com/lastmile-ai/mcp-agent
[2] - https://modelcontextprotocol.io/introduction
[3] - https://www.anthropic.com/research/building-effective-agents
[4] - https://github.com/openai/swarm
[5] - https://microsoft.github.io/language-server-protocol/
[6] - https://xkcd.com/927/ (I understand the irony)
[7] - https://github.com/lastmile-ai/mcp-agent/tree/main/examples", "url": "https://github.com/lastmile-ai/mcp-agent", "upvotes": 80, "comments": 28, "sub": "hackernews", "signal": 20.6, "hits": [ "rag pipeline" ] }, { "src": "github", "id": "1350635588", "title": "IngSquared99/agent-sync", "body": "One source of truth for AI coding agent instructions. Merge rules, skills & workflows from multiple libraries and sync them to Claude Code, OpenAI Codex, Cursor & Google Antigravity — AGENTS.md, .claude/ and .agents/ generated and mounted via symlinks. Zero-dependency Go CLI. ", "url": "https://github.com/IngSquared99/agent-sync", "upvotes": 0, "comments": 3, "sub": "github", "signal": 20.6, "hits": [ "claude code", "coding agent" ] }, { "src": "hackernews", "id": "48200511", "title": "Show HN: AgentWing – make AI agents complete tasks faster", "body": "Hi HN, I’m building AgentWing.
The idea is simple: AI agents usually execute work as one long sequence:
plan → act → wait → observe → act again → verify → finish
That makes agent workflows feel slow, especially when parts of the task do not actually depend on each other.
AgentWing adds a director layer that turns one agent task into multiple isolated worker runs. The director decides which parts can run at the same time, assigns each worker its own scoped job, runs them in parallel, then verifies and combines the result.
For an enterprise-grade setup, each worker can run inside its own isolated VM or sandbox, so every agent has its own environment, files, tools, and execution boundary.
Example:
Task: “Research a market and prepare a competitor summary.”
A normal agent may do this sequentially:
- find competitors\n- analyze pricing\n- compare positioning\n- look for user complaints\n- write summary
AgentWing can run the independent parts in parallel:
- worker A finds competitors\n- worker B analyzes pricing\n- worker C checks positioning\n- worker D gathers user complaints\n- verifier combines the final result
The goal is to make agent tasks feel much closer to instant by removing unnecessary sequential waiting.
I’m experimenting with two modes:
- split mode: different workers handle different parts of one task\n- race mode: duplicate workers try the same subtask and the best verified result wins
This is still early. The hard part is the director: deciding what can safely run in parallel, what must stay sequential, and how to verify the final output.
I’d love feedback on where this breaks, what workflows would benefit most, and what demo would best show the speedup.", "url": "https://news.ycombinator.com/item?id=48200511", "upvotes": 2, "comments": 1, "sub": "hackernews", "signal": 20.3, "hits": [ "agent workflow" ] }, { "src": "github", "id": "1230597745", "title": "MrPeppersDev/agent-infrastructure-landscape", "body": "AI agent memory & infrastructure landscape — comparative catalog of 912 systems × 68 columns covering memory layers, agent frameworks, runtimes, vector stores, knowledge graphs, MCP servers, benchmarks. Searchable with typed edges, lineages, citations. agent-frameworks agent-infrastructure agent-memory ai-agents ai-memory-systems ai-research catalog knowledge-graph langchain letta llm llm-memory mcp mcp-server mem0 rag sveltekit vector-database zep", "url": "https://github.com/MrPeppersDev/agent-infrastructure-landscape", "upvotes": 2, "comments": 31, "sub": "github", "signal": 20.3, "hits": [ "langchain", "benchmark", "vector" ] }, { "src": "hackernews", "id": "45775329", "title": "Context-Bench: Benchmarking LLMs on Agentic Context Engineering", "body": "", "url": "https://www.letta.com/blog/context-bench", "upvotes": 5, "comments": 0, "sub": "hackernews", "signal": 20.2, "hits": [ "context engineering", "benchmark" ] }, { "src": "hackernews", "id": "44604651", "title": "Show HN: Tips for getting great Text2Cypher outputs from LLMs for Graph RAG", "body": "For folks working on Graph RAG and trying to get LLMs to generate Cypher queries, I ran some experiments on the LDBC dataset and wrote a blog post about it (code is available in the link shown at the end of the post). I've been trying to answer a burning question of mine that I've had for a while now: when doing Text2Cypher, are LLMs better at interpreting graph schemas in JSON, XML or YAML? (Spoiler alert, the format barely matters, it's all to do with context engineering and retaining only the relevant parts of the graph schema in the prompt). Results on the latest LLMs are really good!
The post also contains some other tips on graph schema design: I think we're in an age now where we need to design graph schema for both LLMs and humans. If you're working on Text2Cypher in any way, hope some of these ideas and experiments are useful!", "url": "https://blog.kuzudb.com/post/improving-text2cypher-for-graphrag-via-schema-pruning/", "upvotes": 4, "comments": 0, "sub": "hackernews", "signal": 20.2, "hits": [ "context engineering" ] }, { "src": "github", "id": "1344234809", "title": "lightsound/solid2-agent-kit", "body": "Teach AI coding agents (Cursor, Claude Code) to write correct Solid 2.0 — always-applied rules, an agent skill, a mechanical pattern gate, and docs-drift CI. ", "url": "https://github.com/lightsound/solid2-agent-kit", "upvotes": 0, "comments": 1, "sub": "github", "signal": 20.2, "hits": [ "claude code", "coding agent" ] }, { "src": "hackernews", "id": "47720741", "title": "Context Engineering – LLM Memory and Retrieval for AI Agents", "body": "", "url": "https://weaviate.io/blog/context-engineering", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 20.1, "hits": [ "context engineering", "retrieval" ] }, { "src": "hackernews", "id": "44606811", "title": "Show HN: Stop re-explaining context to every LLM (Git-based context engineering)", "body": "I built this because I got annoyed of constantly re-explaining my project to Cursor and Claude Desktop.
I used ctx to build ctx itself - the context persisted across sessions and I could pick up exactly where I left off each time.
ctx is a git-based context manager that “just works” with all LLM tools.\nJust “ctx load” and it’ll pick up exactly where you left off.
How it works:
- “ctx new” creates a git repo for your context (goals, preferences, project state)\n- “ctx save ‘progress update’" versions your context like code\n- “ctx load” gives any LLM your full context instantly\n- Built-in MCP server means it works with Claude Desktop, Cursor, or any MCP-compatible tool\n- every context folder contains ctx.txt which explains exactly what ctx is so LLMs know what to do with it
Under the hood it’s just git and text files - no embeddings, no vendor lock-in. Context windows are getting longer anyway, so just give LLMs well-structured context and help them deal with it
context, much like code, evolves and deserves to be tracked.", "url": "https://github.com/jerpint/context-llemur", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 20.1, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "47330309", "title": "At what level of deep context engineering does AI output become human-crafted?", "body": "I’ve been wrestling with a philosophical and ethical question regarding authorship in the age of LLMs, and I’m curious where the HN community draws the line.
Suppose you spend months deeply researching a niche topic. You make your own discoveries, structure your own insights, and feed all of this tightly curated, highly specific context into an LLM. You essentially build a custom knowledge base and train the model on your exact mental framework.
When you finally want to write a post or comment sharing your findings, you outline your specific thoughts and use that meticulously primed LLM to structure and generate the final prose.
My questions for you:
Is it unethical to post this without an "AI-generated" disclaimer? 2. Whose knowledge is actually being showcased? The LLM is generating the syntax, but the semantics, the insights, and the deep context are 100% human-sourced.
Is this fundamentally different from using a ghostwriter, an editor, or a highly advanced compiler? If I am doing the heavy lifting of context engineering and knowledge discovery, it feels restrictive to say I shouldn't utilize an LLM to structure the final output. Yet, the internet still largely views any AI-generated text as inherently "un-human" or low-effort.
Where does human insight end and AI generation begin? If the core ideas are yours, is the medium of the text really the message?", "url": "https://news.ycombinator.com/item?id=47330309", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 20.1, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "47124474", "title": "Show HN: MarkdownLM – Stop being the human middleware for your AI agent", "body": "I got tired of being the human middleware between my AI agent and my own codebase rules.
Every session my agent would start fresh with no memory of the architectural decisions we had made. It would confidently ignore naming conventions, bypass security patterns, and quietly undo things I had spent weeks getting right.
I tried CLAUDE.md, .cursorrules, plan files, task files. They all have the same ceiling: the agent treats them as suggestions, context windows bury them as sessions grow, and there is zero enforcement when they get violated. The prompt is the spec in AI-native development, and right now that spec disappears every time the chat closes.
MarkdownLM is my attempt to fix the layer below the agent, not by writing better prompts, but by treating your team's engineering rules as infrastructure.
How it works:
Your knowledge base lives in structured categories: architecture decisions, security constraints, business logic, naming conventions, whatever your team actually cares about. When an agent makes a call, MarkdownLM uses semantic embeddings to pull only the relevant rules rather than flooding the prompt with your entire knowledge base. Out of 500 documents, the agent sees the 3 that matter for this specific task. That keeps context focused, tokens low, and the agent from getting lost in irrelevant rules.
Before generation, relevant context is injected. After generation, a validation gate checks the output against your rules and blocks violations with a receipt showing the specific rule, the reason, and the smallest suggested fix. When the agent hits something ambiguous with no rule coverage, it does not guess and ship. It stops, flags it as a gap, and routes it to whoever you have designated as the decision maker for that category.
Everything is MCP-native so it works across Cursor, Claude Code, and any MCP-compatible host without changing your workflow. The CLI lets you manage your knowledge base from the terminal like code: clone, diff, push, sync across your team.
What I learned building it:
The interesting part was realizing the cost structure. Using Google's text-embedding-004 at $0.15 per million input tokens to retrieve the right 3 documents means the retrieval layer costs fractions of a cent per call. That cheap embedding lookup replaces what would otherwise be a 100k-token prompt. Lower cost and better results because focused context beats large context almost every time.
The gap resolution feature surprised me most in practice. Teams do not just have rule violations. They have rule gaps, situations the agent encounters that nobody thought to write a rule for yet. Surfacing those gaps as actionable items rather than silent guesses turned out to be as useful as the enforcement itself.
Current state:
Public beta. BYOK is free, no credit card. Your code never touches our servers. The CLI and MCP server are open source on GitHub. Will stay free for individuals because I know the pain.
Site: https://markdownlm.com\nCLI: https://github.com/MarkdownLM/cli\nMCP: https://github.com/MarkdownLM/mcp
I am the solo founder. Brutal feedback is the only feedback I want.", "url": "https://news.ycombinator.com/item?id=47124474", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 20.1, "hits": [ "claude code", "retrieval" ] }, { "src": "hackernews", "id": "46234309", "title": "Why Your RAG Costs $2,400/Month (and How We Cut It by 73%)", "body": "You're running RAG in production. Then the AWS bill lands. $2,400/month for 50 queries/day. $48 per query.
We built a RAG system for enterprise clients and realized most production RAGs are optimization disasters. The literature obsesses over accuracy while completely ignoring unit economics.
The Three Cost Buckets\nVector Database (40-50% of bill)\nStandard RAG pipelines do 3-5 unnecessary DB queries per question. We were making 5 round-trips for what should've been 1.5.
LLM API (30-40%)\nStandard RAG pumps 8-15k tokens into the LLM. That's 5-10x more than necessary. We found: beyond 3,000 tokens of context, accuracy plateaus. Everything beyond that is noise and cost.
Infrastructure (15-25%)\nVector databases sitting idle, monitoring overhead, unnecessary load balancing.
What Actually Moved the Needle\nToken-Aware Context (35% savings)\nBudget-based assembly that stops when you've used enough tokens. Before: 12k tokens/query. After: 3.2k tokens. Same accuracy.
python\ndef _build_context(self, results, settings):\n max_tokens = settings.get("max_context_tokens", 2000)\n current_tokens = 0\n for result in results:\n tokens = self.llm.count_tokens(result)\n if current_tokens + tokens <= max_tokens:\n current_tokens += tokens\n else:\n break\nHybrid Reranking (25% savings)\n70% semantic + 30% keyword scoring. Better ranking means fewer chunks needed. Top-20 → top-8 retrieval while maintaining quality.
Embedding Caching (20% savings)\nWorkspace-isolated cache with 7-day TTL. We see 45-60% hit rate intra-day.
python\nasync def set_embedding(self, text, embedding, workspace_id=None):\n key = f"embedding:ws_{workspace_id}:{hash(text)}"\n await redis.setex(key, 604800, json.dumps(embedding))\nBatch Embedding (15% savings)\nBatch API pricing is 30-40% cheaper per token. Process 50 texts simultaneously instead of individu", "url": "https://news.ycombinator.com/item?id=46234309", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 20.1, "hits": [ "rag pipeline", "retrieval", "vector" ] }, { "src": "hackernews", "id": "45238432", "title": "Show HN: VittoriaDB – Zero-config embedded vector DB with HNSW and ACID storage", "body": "Hi HN! I built VittoriaDB as a zero-configuration embedded vector database that actually works out of the box for local AI development.
Core features:
• Zero-configuration embedded vector database - no setup, no config files
• HNSW indexing for sub-millisecond vector similarity search
• ACID-compliant storage with write-ahead logging for data integrity
• Complete REST API for language-agnostic integration
• Single Go binary - 8MB download, runs anywhere
• Python SDK with automatic binary management
Technical highlights:
The database uses HNSW (Hierarchical Navigable Small World) graphs for efficient approximate nearest neighbor search, achieving 2.6M+ vectors/sec insert rates and sub-millisecond query latency. Storage is ACID-compliant with WAL (Write-Ahead Logging) for crash recovery and data consistency.
Local AI integration:
Built-in Ollama integration provides high-quality ML embeddings without API costs or internet dependencies. Upload documents (PDF, DOCX, MD, HTML) and get automatic chunking, vectorization, and semantic search - the complete RAG pipeline runs locally.
Unlike hosted vector databases, VittoriaDB runs as part of your application process. No separate infrastructure, no network latency, no external dependencies. Perfect for local development, edge deployments, or anywhere you need vector search without operational complexity.
Performance benchmarks:
• Insert speed: 2.6M+ vectors/second
• Search latency: <1ms for optimized queries
• Memory usage: Linear scaling (1MB per 1K vectors)
• Binary size: 8MB compressed
Real-world usage:\nDevelopers use it for RAG applications, semantic search, document processing, and AI prototyping where you need production-grade vector operations without database administration overhead.
Links:
• GitHub: https://github.com/antonellof/VittoriaDB
• PyPI: https://pypi.org/project/vittoriadb/
• Install: pip install vittoriadb", "url": "https://github.com/antonellof/VittoriaDB", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 20.1, "hits": [ "rag pipeline", "benchmark", "vector" ] }, { "src": "hackernews", "id": "46264972", "title": "Show HN: I built a circuit breaker that predicts AI failures", "body": "Hi HN — I built this and I’m explicitly asking skeptics to tear it apart.”\nInterlock is a safety and certification layer for AI infrastructure, not an optimizer or a vector database.
The problem I am solving for is that AI systems (vector search, RAG pipelines, agent frameworks) don’t usually fail cleanly — they degrade silently, oscillate under load, or keep returning corrupted results until something crashes. Monitoring tells you after the fact; circuit breakers tend to be static and blind to context.
Interlock tries to address that by:
forecasting time-to-failure under stress
intervening before hard limits are reached
refusing to serve results when confidence collapses
producing cryptographically signed evidence of what happened (control vs protected runs)
It includes:
integrations with FAISS, Pinecone, Weaviate, Milvus, LangChain, LlamaIndex (Elasticsearch experimental)
TypeScript + Python support
automated stress tests (control vs protected)
long-run stability tests
certification classes (I–V) derived from actual configuration + behavior, not labels
Importantly: Interlock does not guarantee correctness or uptime. It certifies that a given configuration survived a defined stress test without crashing, oscillating, or serving degraded results — similar to a structural load rating rather than a promise.
The repo is fully open source, and all claims link to test artifacts and CI runs. I’m especially interested in feedback on:
failure modes this wouldn’t catch
where the certification model is too strict or too weak
whether this is actually useful in real production AI systems
Repo: https://github.com/CULPRITCHAOS/Interlock
Happy to answer questions or be told why this is a bad idea lol", "url": "https://github.com/CULPRITCHAOS/Interlock", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 20.1, "hits": [ "rag pipeline", "langchain", "vector" ] }, { "src": "github", "id": "1336146303", "title": "MoeenUddin01/SpecRAG", "body": "A modular, spec-driven RAG architecture for intelligent document retrieval and LLM context engineering. ", "url": "https://github.com/MoeenUddin01/SpecRAG", "upvotes": 0, "comments": 0, "sub": "github", "signal": 20.0, "hits": [ "context engineering", "retrieval" ] }, { "src": "hackernews", "id": "43846964", "title": "Show HN: Create your own finetuned AI model using Google Sheets", "body": "Hello HN,
We built Promptrepo to make finetuning accessible to product teams — not just ML engineers. Last week, OpenAI’s CPO shared how they use fine-tuning for everything from customer support to deep research, and called it the future for serious AI teams. Yet most teams I know still rely on prompting, because fine-tuning is too technical, while the people who have the training data (product managers and domain experts) are often non-technical. With Promptrepo, they can now:
- Add training examples in Google Sheets
- Click a button to train
- Deploy and test instantly
- Use OpenAI, Claude, Gemini or Llama models
We’ve used this internally for years to power AI workflows in our products (Formfacade, Formesign, Neartail), and we're now opening it up to others. Would love your feedback and happy to answer any questions!
---
Try it free - https://promptrepo.com/finetune
Demo video - https://www.youtube.com/watch?v=e1CTin1bD0w
Why we built it - https://guesswork.co/support/post/fine-tuning-is-the-future-...", "url": "https://promptrepo.com/finetune/", "upvotes": 137, "comments": 41, "sub": "hackernews", "signal": 19.9, "hits": [] }, { "src": "hackernews", "id": "45903161", "title": "Launch HN: JSX Tool (YC F25) – A Browser Dev-Panel IDE for React", "body": "Hi HN, We’re Jamie & Dan, building JSX Tool (https://jsxtool.com) a new inspector/dev panel IDE that allows you to navigate to any line of your React project’s JSX with just a click and a command click to explore your render stack.
Demo video: https://www.youtube.com/watch?v=JIIXvN7vhrs
I’ve been writing React code for nearly a decade. Since I first saw source maps in the days of Babel and Redux, I’ve always wanted to be able to edit my code from the source maps. I’ve also always wanted to be able to inspect my JSX like it was HTML.
Last year, I found my first real use of AI was taking ad-hoc CSS changes in the Chrome element inspector, pasting them into ChatGPT, and asking for the equivalent in Tailwind. I’d then paste those changes into my React TSX files.
I wanted to streamline this process but came to the conclusion that to do so I needed to build a JSX inspector. I had to write a custom AST parser to create a mapping between the JSX and HTML. So I hacked on an inspector for a couple of months that connected JSX to the DOM in both directions.
The next feature was adding a CSS editor, like the one in the browser inspectors but for JSX. Unlike styling a piece of HTML I decided that any in memory style edits to a React fiber should be globally applied, as if you had tweaked that line of code in your codebase.
Finally, I was able to add the two AI features I really wanted: (1) prompt for in-memory styles for when I was pixel tweaking, and (2) save those temporary changes back to my codebase in the convention of the codebase I was working in.
To accomplish talking to the filesystem from the Chrome extension I built a little local server that mounts from the root of your project and allows the extension to send file-system commands back to your project root. We named this the “Dev Server”. (Note: You can fully use us as a JSX inspector without this server installed.)
After all that, I found that to convert myself as a user I needed it to be a pretty fully functional IDE. I needed vim bindings, I needed a typechecker, I needed auto-complete, I needed a linter, I needed code search and I needed a proper file explorer. Fortunately we were able to take advantage of the dev-server architecture we had stumbled onto in order to add an LSP server and Rip Grep. At this point, after months of dog fooding, I use JSX Tool for almost all of my website edits.
We’re still rough around the edges for mobile but we’re working on that.
All of the IDE stuff not involving AI is free and works fine without AI. We let you get a taste of the prompting stuff for free but apply some rate limits.
The extension itself is not open source but the dev server with the LSP is. It’s a great foundation if you want to build any sort of in-browser IDE and it's nearly React agnostic. Building the dev server was a big undertaking so I’d love to see someone fork it and find value in it.
In the future we want to start adding things that we are in a position to take advantage of over something like Cursor, such as letting AI give you code suggestions for runtime exceptions or work with the network logs. We think that the convenience of having your IDE in the dev panel gives us a leg up in convenience and workflow context.
Anyway, regardless of how you feel about AI coding, I wanted to make something that was useful with or without AI. We’d love it if you gave it a spin and we want to share anything we can about the technical side of the product that you might find interesting.", "url": "https://news.ycombinator.com/item?id=45903161", "upvotes": 111, "comments": 83, "sub": "hackernews", "signal": 18.6, "hits": [] }, { "src": "github", "id": "1018884220", "title": "Drlinglong/Remis", "body": "AI-native desktop localization system for Paradox mods—LLM orchestration, context engineering, structured validation, repair loops, human review, and local-first project control. agentic-ai ai fastapi human-in-the-loop llm llmops localization modding paradox-games pydantic-ai python rag react tauri", "url": "https://github.com/Drlinglong/Remis", "upvotes": 25, "comments": 11, "sub": "github", "signal": 18.4, "hits": [ "context engineering" ] }, { "src": "lobsters", "id": "v8hk8q", "title": "Google’s exponential path to climate-wrecking digital bloat", "body": "", "url": "https://ketanjoshi.co/2026/07/01/googles-exponential-path-to-climate-wrecking-digital-bloat/", "upvotes": 140, "comments": 26, "sub": "ai", "signal": 18.2, "hits": [] }, { "src": "github", "id": "1311038225", "title": "The-AIE/the-gibson", "body": "A portable, self-improving SDLC harness for agent fleets — plan → issues → build → test → review → UX-eval → security → ship, on any runtime (Claude Code, Codex, Grok, Hermes). Apache-2.0. agentic-development ai-agents claude-code codex harness playwright sdlc vercel", "url": "https://github.com/The-AIE/the-gibson", "upvotes": 1, "comments": 65, "sub": "github", "signal": 18.1, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "46873742", "title": "Show HN: I built \"AI Wattpad\" to eval LLMs on fiction", "body": "I've been a webfiction reader for years (too many hours on Royal Road), and I kept running into the same question: which LLMs actually write fiction that people want to keep reading? That's why I built Narrator (https://narrator.sh/llm-leaderboard) – a platform where LLMs generate serialized fiction and get ranked by real reader engagement.
Turns out this is surprisingly hard to answer. Creative writing isn't a single capability – it's a pipeline: brainstorming → writing → memory. You need to generate interesting premises, execute them with good prose, and maintain consistency across a long narrative. Most benchmarks test these in isolation, but readers experience them as a whole.
The current evaluation landscape is fragmented:\nMemory benchmarks like FictionLive's tests use MCQs to check if models remember plot details across long contexts. Useful, but memory is necessary for good fiction, not sufficient. A model can ace recall and still write boring stories.
Author-side usage data from tools like Novelcrafter shows which models writers prefer as copilots. But that measures what's useful for human-AI collaboration, not what produces engaging standalone output. Authors and readers have different needs.
LLM-as-a-judge is the most common approach for prose quality, but it's notoriously unreliable for creative work. Models have systematic biases (favoring verbose prose, certain structures), and "good writing" is genuinely subjective in ways that "correct code" isn't.
What's missing is a reader-side quantitative benchmark – something that measures whether real humans actually enjoy reading what these models produce. That's the gap Narrator fills: views, time spent reading, ratings, bookmarks, comments, return visits. Think of it as an "AI Wattpad" where the models are the authors.
I shared an early DSPy-based version here 5 months ago (https://news.ycombinator.com/item?id=44903265). The big lesson: one-shot generation doesn't work for long-form fiction. Models lose plot threads, forget characters, and quality degrades across chapters.
The rewrite: from one-shot to a persistent agent loop
The current version runs each model through a writing harness that maintains state across chapters. Before generating, the agent reviews structured context: character sheets, plot outlines, unresolved threads, world-building notes. After generating, it updates these artifacts for the next chapter. Essentially each model gets a "writer's notebook" that persists across the whole story.
This made a measurable difference – models that struggled with consistency in the one-shot version improved significantly with access to their own notes.
Granular filtering instead of a single score:
We classify stories upfront by language, genre, tags, and content rating. Instead of one "creative writing" leaderboard, we can drill into specifics: which model writes the best Spanish Comedy? Which handles LitRPG stories with Male Leads the best? Which does well with romance versus horror?
The answers aren't always what you'd expect from general benchmarks. Some models that rank mid-tier overall dominate specific niches.
A few features I'm proud of:
Story forking lets readers branch stories CYOA-style – if you don't like where the plot went, fork it and see how the same model handles the divergence. Creates natural A/B comparisons.
Visual LitRPG was a personal itch to scratch. Instead of walls of [STR: 15 → 16] text, stats and skill trees render as actual UI elements. Example: https://narrator.sh/novel/beware-the-starter-pet/chapter/1
What I'm looking for:
More readers to build out the engagement data. Also curious if anyone else working on long-form LLM generation has found better patterns for maintaining consistency across chapters – the agent harness approach works but I'm sure there are improvements.", "url": "https://narrator.sh/llm-leaderboard", "upvotes": 32, "comments": 32, "sub": "hackernews", "signal": 18.0, "hits": [ "benchmark" ] }, { "src": "hackernews", "id": "45735886", "title": "Show HN: MCP-C – cloud platform for running MCP agents and apps", "body": "Hello HN!
Earlier this year, we shared mcp-agent (https://github.com/lastmile-ai/mcp-agent) [1][2], a lightweight framework for building agents with MCP. Since then we have tried to push the protocol to the limits, including hosting agents as long-running tools on MCP [3], and seen other creative approaches surface (mcp-ui, chatgpt apps sdk).
Today, we are launching mcp-c – a cloud platform designed for hosting any kind of MCP server, including agents, ChatGPT apps, etc. We are in open beta and free to use, and would love your feedback.
Here are some key choices we made:
1) Everything is MCP - Each application is deployed as a remote SSE endpoint, and implements the full MCP spec, including advanced features like elicitation, sampling, notifications and logging.
2) Durable execution via Temporal - We use Temporal as the runtime environment, allowing you to run long-running operations. This is especially critical for agents, which need to pause/resume, be fault-tolerant, and run for a long time.
3) Local to Cloud - we're fans of how easy it is to deploy a Next.js app to Vercel, so we've made it simple to take your local mcp-agent, mcp server, OpenAI app, etc. and deploy it to the cloud. We have several examples and even a handy CLI to get started quickly [4].
It's as simple as:
- uvx mcp-agent init
- uv init
- uv add "mcp-agent[openai]"
- uvx mcp-agent login
# add your openai key to mcp_agent.secrets.yaml
- uvx mcp-agent deploy
You can also try out these hosted mcp servers to get an idea. These can be connected to any MCP client (ChatGPT, Claude Desktop/Code, Cursor, etc.)
OpenAI Pizza App - https://18t536mliucyeuhkkcnjdavxtyg66pgl.deployments.mcp-age...
Basic Agent Server - https://1m82g32x8nkoppinayx0k5ye12oar6vk.deployments.mcp-age...
The HN community has been a big part of mcp-agent's growth, and we're super excited to share this with you as well. We would love to hear your thoughts and feedback!
---
[1] - https://news.ycombinator.com/item?id=42867050
[2] - https://github.com/lastmile-ai/mcp-agent
[3] - https://news.ycombinator.com/item?id=44053754
[4] - https://github.com/lastmile-ai/mcp-agent/tree/main/examples/...
[5] - https://docs.mcp-agent.com/get-started/welcome
[6] - https://youtu.be/9ddtaSbUJIc", "url": "https://docs.mcp-agent.com/get-started/cloud", "upvotes": 9, "comments": 2, "sub": "hackernews", "signal": 17.9, "hits": [ "mcp agent" ] }, { "src": "hackernews", "id": "43772582", "title": "Show HN: CocoIndex – Open-Source Data framework for AI, built for data freshness", "body": "Hi HN, I’ve been working on CocoIndex, an open-source Data ETL framework to transform data for AI, optimized for data freshness.
You can start a CocoIndex project with `pip install cocoindex` and declare a data flow that can build ETL like LEGO - build a RAG pipeline for vector embeddings, knowledge graphs, or extract, transform data with LLMs. It is a data processing framework beyond text. When you run the data flow either with live mode or batch mode, it will process the data incrementally with minimal recomputation and make it super fast to update the target stores on source changes.
Get started video: https://www.youtube.com/watch?v=gv5R8nOXsWU\nDemo video: https://www.youtube.com/watch?v=ZnmyoHslBSc
Previously, I’ve worked at Google on projects like search indexing and ETL infra for 8 years. After I left Google last year, I built various projects and went through pivoting hell. In all the projects I’ve built, data still sits in the center of the problem and I find myself focusing on building data infra other than the business logic I need for data transformation. The current prepackaged RAG-as-service doesn't serve my needs, because I need to choose a different strategy for the context, and I also need deduplication, clustering (items are related), and other custom features that are commonly needed. That’s where CocoIndex starts.
A simple philosophy behind it - data transformation is similar to formulas in spreadsheets. The ground of truth is at the source data, and all the steps to transform, and final target store are derived data, and should be reactive based on the source change. If you use CocoIndex, you only need to worry about defining transformations like formulas.
*Data flow paradigm* came in as an immediate choice - because there’s no side effect, lineage and observability just come out of the box.
*Incremental processing* - If you are a data expert, an analogy would be a materialized view beyond SQL. The framework tracks pipeline states in database, and only reprocessing necessary portions. When data has changed,\nframework handles the change data capture comprehensively and combines the mechanism for push and pull. Then clear stale derived data/versions and re-index data based on tracking data/logic changes or data TTL settings. There’s lots of edge cases to do it right, for example, when a row is referenced in other places, and the row changes. These should be handled at the level of the framework.
*At the compute engine level* - the framework should consider the multiple processes and concurrent updates. It should consider how to resume existing states from terminated execution. In the end, we want to build a framework that is easy to build with exceptional velocity, but scalable and robust in production.
*Standardized the interface throughout the data flow* - really easy to plugin custom logic like LEGO; with a variety of native built-in components. One example is that it takes a few lines to switch among Qdrant, Postgres, Neo4j.
CocoIndex is licensed under Apache 2.0 https://github.com/cocoindex-io/cocoindex
Getting started: https://cocoindex.io/docs/getting_started/quickstart
Excited to learn your thoughts, and thank you so much!\nLinghua", "url": "https://github.com/cocoindex-io/cocoindex", "upvotes": 14, "comments": 11, "sub": "hackernews", "signal": 17.9, "hits": [ "rag pipeline", "vector" ] }, { "src": "hackernews", "id": "47017912", "title": "Show HN: PolyMCP – A framework for building and orchestrating MCP agents", "body": "Hi everyone,
I’ve been working on PolyMCP, an open-source framework for building and orchestrating agents using the Model Context Protocol (MCP).
Most of the tooling around MCP focuses on exposing tools. With PolyMCP, the focus this time is on agents: how to structure them, connect them to multiple MCP servers, and make them reliable in real workflows.
PolyMCP provides:\n • A clean way to define MCP-compatible tool servers in Python or TypeScript\n • An agent abstraction that can connect to multiple MCP endpoints (stdio, HTTP, etc.)\n • Built-in orchestration primitives for multi-step tasks\n • A CLI to scaffold projects and run an inspector UI to debug tools and agent interactions\n • A modular structure that makes it easier to compose skills and reuse components across projects
The main goal is to make agent systems less ad-hoc. Instead of writing glue code around each model + tool combination, PolyMCP gives you a structured way to:\n • Register tools as MCP servers\n • Connect them to one or more agents\n • Control execution flow and state\n • Inspect and debug interactions
It’s MIT licensed and intended for developers building real-world automation, internal copilots, or multi-tool assistants.
I’d love feedback on:\n • The agent abstraction: is it too opinionated or not opinionated enough?\n • Orchestration patterns for multi-agent setups\n • Developer experience (CLI, inspector, project layout)
Happy to answer questions.", "url": "https://news.ycombinator.com/item?id=47017912", "upvotes": 3, "comments": 2, "sub": "hackernews", "signal": 17.6, "hits": [ "mcp agent" ] }, { "src": "hackernews", "id": "42857980", "title": "Show HN: Jay - Fully programmable, fully hosted AI voice agents", "body": "Hey everyone, we’re excited to announce Jay, a platform for building voice agents that hosts all of the agent’s infra while giving you full control over how the agent responds. Our goal is to give developers a Vercel-like experience for building voice agents.
Currently, voice frameworks are either fully hosted with limited customizability (e.g. Vapi, Retell), or fully customizable while requiring you to host and scale the agent yourself (Livekit, Pipecat). We weren’t satisfied with these options, so we built Jay.
Jay makes it easy for you to add custom logic such as a RAG pipeline, an arbitrary LLM provider, or anything else that controls the LLM’s response. It’s built on top of the standard STT → LLM → TTS pipeline, and handles things like voice interruptions automatically. It also supports function calling (i.e. tool calls).
You can deploy your first agent to production in just a few minutes.
Try it out here, and let us know what you think! https://jay.so/", "url": "https://www.jay.so/", "upvotes": 3, "comments": 2, "sub": "hackernews", "signal": 17.6, "hits": [ "rag pipeline", "function calling" ] }, { "src": "hackernews", "id": "43603324", "title": "Alternative of MCP with AI RAG Agentic Framework", "body": "If you've tried building AI agentic systems on top of Model Context Protocol (MCP), you've likely run into the same issues we did: integration complexity, lack of UI support, high token costs, and hallucination-prone outputs. That’s why we built something better—Oqlous AI’s RAG Agentic Framework, designed from the ground up to be practical, scalable, and user-friendly.
Let me break it down.
What’s Wrong with MCP?
While MCP introduced an interesting idea around managing AI context and action workflows, it suffers from some critical
limitations:
No UI/End-User Layer
MCP provides no native UI support. You prompt it to create a JIRA ticket, and you get a text response. That’s it. No interactive layer, no native app UIs.
Token Inefficiency
MCP agents burn through tokens quickly, leading to higher cost and slower throughput. Not scalable for real-time or production use.
Shallow Execution
There’s no real multi-app, multi-hop reasoning. MCP can’t take a task, pull data from three apps, synthesize a decision, and then execute downstream actions. It just doesn't go that deep.
Hallucinations and Fragility
Output quality is unreliable. Responses can be vague, hallucinated, or misaligned with business context. Customization is minimal.
Oqlous AI RAG Agentic Framework: Built for Real Execution\nWe built Oqlous AI to solve all of the above—and more.
One-Click App Integrations
No need for manual config files or external orchestrators. You can connect to tools like Gmail, JIRA, Notion, Drive, and more with a click having 100+ integrations.
End-to-End UI Support
When you prompt the agent to "create a JIRA task," you don’t get just text—you get a full JIRA UI component within the workflow. You can interact with it, update fields, drag tickets, and more, like you would in the native app.
Efficient LLM Usage
Thanks to smart token management and modular RAG strategies, Oqlous AI consumes significantly fewer tokens per operation. That means up to three times faster execution and lower costs, while keeping responses grounded.
Deep Agentic Workflows
Oqlous AI agents can reason across multiple tools. Say you ask, "Schedule a meeting with Alice, summarize the latest engineering report, and create follow-up tasks in Asana." Oqlous agents will fetch the report from Notion, parse action items, schedule via Calendar, and push tasks—all autonomously.
Customizable to Enterprise Workflows
Every enterprise has unique needs. Oqlous AI’s framework allows easy customization of agent behavior, integrations, and guardrails. You’re not stuck with rigid chains or black-box flows.
Grounded, Reliable Output
With RAG plus fine-tuned execution layers, hallucinations are drastically reduced. Agents don’t guess—they check, verify, and act based on actual data.
Summary
MCP had promise but isn't built for real-world execution at scale. Oqlous AI’s RAG Agentic Framework is.
If you're looking for an enterprise-ready, highly efficient, and deeply interactive AI agent system, Oqlous AI is the upgrade MCP never became.
We're opening this up for developers, startups, and enterprises building the next generation of agentic applications. Happy to connect with anyone working in this space.
Happy to give you acess: https://www.oqlous.com/get-started", "url": "https://news.ycombinator.com/item?id=43603324", "upvotes": 2, "comments": 1, "sub": "hackernews", "signal": 17.3, "hits": [ "mcp agent" ] }, { "src": "github", "id": "1346774681", "title": "Ilyat9/Agentalyze", "body": "Evaluation harness for LLM browser agents — real Chromium tasks, DOM-based verifiers, step-level tracing, multi-provider benchmarks and CI regression checks. agent-testing ai-agent-evaluation benchmark browser-automation chromium ci-cd llm-agent llm-agents llm-evaluation ollama openai plawyright python python3", "url": "https://github.com/Ilyat9/Agentalyze", "upvotes": 1, "comments": 1, "sub": "github", "signal": 17.2, "hits": [ "evaluation harness", "benchmark" ] }, { "src": "hackernews", "id": "47047299", "title": "Show HN: PolyClaw – Autonomous Docker-First MCP Agent for PolyMCP", "body": "I built PolyClaw, an autonomous agent for the PolyMCP ecosystem inspired by OpenClaw.
PolyClaw doesn’t just call tools.\nIt plans, executes, adapts — and even creates MCP servers when needed.
It’s designed for real-world, multi-step production workflows where an agent must:\n • Orchestrate multiple tools\n • Spin up infrastructure dynamically\n • Recover from failures\n • Deliver complete, end-to-end results
⸻
What PolyClaw Does\n • Decomposes complex tasks into executable steps\n • Dynamically selects and orchestrates MCP tools\n • Spins up or connects to MCP servers on demand\n • Adapts if execution fails or context changes\n • Validates outputs before proceeding\n • Runs Docker-first for isolation and safety\n • Built with Python + TypeScript
PolyClaw is not just a tool-caller — it’s an infrastructure-aware agent.
⸻
Run PolyClaw (via PolyMCP CLI)
polymcp agent run \\\n --type polyclaw \\\n --query "Build a sales reporting pipeline and test it end-to-end" \\\n --model minimax-m2.5:cloud \\\n --verbose
What happens behind the scenes:\n 1. The task is decomposed into structured steps\n 2. Required MCP tools are identified\n 3. MCP servers are started or connected\n 4. Steps execute (sequentially or in parallel)\n 5. Outputs are validated\n 6. Failures trigger adaptive replanning\n 7. A complete, end-to-end result is returned
All containerized. All isolated.
⸻
Why This Matters
Most AI agents today:\n • Call tools statically\n • Assume infrastructure already exists\n • Break on multi-step failures
PolyClaw instead:\n • Builds the infrastructure it needs\n • Orchestrates across multiple MCP servers\n • Handles retries and adaptive planning\n • Is safe to run in Dockerized environments
This makes it viable for:\n • Enterprise workflows\n • DevOps automation\n • Data pipelines\n • Internal tooling orchestration\n • Complex multi-tool reasoning tasks
PolyClaw turns PolyMCP from simple tool exposure into a fully autonomous orchestration layer.
Repo: https://github.com/poly-mcp/PolyMCP
Happy to answer questions.", "url": "https://news.ycombinator.com/item?id=47047299", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 17.1, "hits": [ "mcp agent" ] }, { "src": "hackernews", "id": "47036828", "title": "Show HN: PolyClaw – An Autonomous Docker-First MCP Agent for PolyMCP", "body": "I built PolyClaw, an OpenClaw-inspired autonomous agent for the PolyMCP ecosystem.
PolyClaw doesn’t just call tools.\nIt plans, executes, adapts — and creates MCP servers when needed.
It’s designed for real multi-step, production workflows where agents must orchestrate tools, spin up infrastructure, recover from errors, and deliver complete results end-to-end.
⸻
What PolyClaw Does\n • Plans complex multi-step tasks\n • Executes and orchestrates MCP tools dynamically\n • Adapts when steps fail or context changes\n • Creates and connects MCP servers on the fly\n • Runs Docker-first for safety and isolation\n • Built with Python and TypeScript
PolyClaw is not just a tool caller — it’s an infrastructure-aware agent.
⸻
Run PolyClaw with Ollama
You can launch PolyClaw directly from the PolyMCP CLI:
polymcp agent run \\\n --type polyclaw \\\n --query "Build a sales reporting pipeline and test it end-to-end" \\\n --model minimax-m2.5:cloud \\\n --verbose
What happens behind the scenes:\n 1. The agent decomposes the task.\n 2. It determines which MCP tools are required.\n 3. It spins up or connects to MCP servers.\n 4. It executes steps in sequence (or parallel when needed).\n 5. It validates outputs.\n 6. It adapts if something fails.\n 7. It returns a complete result.
All containerized. All isolated.
⸻
Why This Matters
Most AI agents:\n • Call tools statically\n • Assume infrastructure already exists\n • Break on multi-step failure
PolyClaw:\n • Builds the infrastructure it needs\n • Orchestrates across multiple MCP servers\n • Handles retries and adaptive planning\n • Is safe to run in Dockerized environments
This makes it viable for:\n • Enterprise workflows\n • DevOps automation\n • Data pipelines\n • Internal tooling orchestration\n • Complex multi-tool reasoning tasks
PolyClaw turns PolyMCP from simple tool exposure only with Polyagent e unifiendpolyagent or codeagent but turn into full autonomous orchestration agent too.
Repo:\nhttps://github.com/poly-mcp/PolyMCP
Happy to answer questions,", "url": "https://news.ycombinator.com/item?id=47036828", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 17.1, "hits": [ "mcp agent" ] }, { "src": "hackernews", "id": "45693834", "title": "Show HN: MCP-C – cloud platform for running MCP agents and apps", "body": "Hello HN!
Earlier this year, we shared mcp-agent (https://github.com/lastmile-ai/mcp-agent) [1][2], a lightweight framework for building agents with MCP. Since then we have tried to push the protocol to the limits, including hosting agents as long-running tools on MCP [3], and seen other creative approaches surface (mcp-ui, chatgpt apps sdk).
Today, we are launching mcp-c – a cloud platform designed for hosting any kind of MCP server, including agents, ChatGPT apps, etc. We are in open beta and free to use, and would love your feedback.
Here are some key choices we made:
1) Everything is MCP - Each application is deployed as a remote SSE endpoint, and implements the full MCP spec, including advanced features like elicitation, sampling, notifications and logging.
2) Durable execution via Temporal - We use Temporal as the runtime environment, allowing you to run long-running operations. This is especially critical for agents, which need to pause/resume, be fault-tolerant, and run for a long time.
3) Local to Cloud - we're fans of how easy it is to deploy a Next.js app to Vercel, so we've made it simple to take your local mcp-agent, mcp server, OpenAI app, etc. and deploy it to the cloud. We have several examples and even a handy CLI to get started quickly [4].
It's as simple as:
- uvx mcp-agent init
- uv init
- uv add "mcp-agent[openai]"
- uvx mcp-agent login
# add your openai key to mcp_agent.secrets.yaml
- uvx mcp-agent deploy
You can also try out these hosted mcp servers to get an idea. These can be connected to any MCP client (ChatGPT, Claude Desktop/Code, Cursor, etc.)
OpenAI Pizza App - https://18t536mliucyeuhkkcnjdavxtyg66pgl.deployments.mcp-age...
Basic Agent Server - https://1m82g32x8nkoppinayx0k5ye12oar6vk.deployments.mcp-age...
The HN community has been a big part of mcp-agent's growth, and we're super excited to share this with you as well. We would love to hear your thoughts and feedback!
---
[1] - https://news.ycombinator.com/item?id=42867050
[2] - https://github.com/lastmile-ai/mcp-agent
[3] - https://news.ycombinator.com/item?id=44053754
[4] - https://github.com/lastmile-ai/mcp-agent/tree/main/examples/...
[5] - https://docs.mcp-agent.com/get-started/welcome", "url": "https://docs.mcp-agent.com/cloud/overview", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 17.1, "hits": [ "mcp agent" ] }, { "src": "hackernews", "id": "47026179", "title": "Show HN: PolyMCP – A framework for structuring and orchestrating MCP agents", "body": "I’ve been working on PolyMCP, an open-source framework designed to make it easier to build and coordinate agents using the Model Context Protocol (MCP).
Most MCP tooling today focuses primarily on exposing tools. PolyMCP instead targets the agent layer: how to structure agents properly, connect them to multiple MCP servers, and make them reliable in real-world workflows.
PolyMCP provides:\n • A clean way to implement MCP-compatible tool servers in Python or TypeScript\n • An agent abstraction that can connect to multiple MCP endpoints (stdio, HTTP, etc.)\n • Built-in orchestration primitives for handling multi-step tasks\n • A CLI to scaffold projects and run an inspector UI to debug tools and agent interactions\n • A modular architecture that makes it easier to compose skills and reuse components across projects
The goal is to reduce ad-hoc glue code between models and tools. Instead of manually wiring everything together for each new setup, PolyMCP offers a structured way to:\n • Register tools as MCP servers\n • Attach them to one or more agents\n • Explicitly manage execution flow and state\n • Inspect and debug interactions
It’s MIT licensed and aimed at developers building production-grade automation, internal copilots, or multi-tool assistants.
Repository: https://github.com/poly-mcp/PolyMCP", "url": "https://news.ycombinator.com/item?id=47026179", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 17.1, "hits": [ "mcp agent" ] }, { "src": "hackernews", "id": "41268315", "title": "Show HN: Easily generate text and compute probabilities for any Hugging Face LLM", "body": "A python library and command line scripts to simplify working with language models.
In the course of studying EleutherAI's Language Model Evaluation Harness, we found ourselves wanting to be able to use their clean LM interface for our own projects, particularly with models from the Hugging Face model hub. Starting from the lm-evaluation-harness code, we built a standalone HFLM class that you can easily import into your Python projects to quickly generate text and compute log probabilities of arbitrary strings.
We also wrote two scripts to let you play with LMs from the command line: lmprob takes a model and a string and returns the log probability of the string according to the model, and lmgen takes a model and a string and generates some completion text. If you've ever wanted to write shell scripts that make decisions and take actions using an LLM, these scripts will help you do that.", "url": "https://github.com/RichardKelley/hflm", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 17.1, "hits": [ "evaluation harness" ] }, { "src": "github", "id": "1347707392", "title": "tokencanopy/e2a-bench", "body": "Benchmark + evaluation harness for e2a: structural-hiding email prompt-injection corpus, multi-detector eval, LLM-judge scores (EMNLP 2026 System Demonstrations) ", "url": "https://github.com/tokencanopy/e2a-bench", "upvotes": 1, "comments": 0, "sub": "github", "signal": 17.1, "hits": [ "evaluation harness", "benchmark" ] }, { "src": "github", "id": "1262894200", "title": "victorzhong0110/da-verify", "body": "A data-analysis LLM agent + a trustworthy evaluation harness. Controlled study (C0/C1/C2) of whether verification improves agent accuracy — paired stats (Wilson/McNemar/bootstrap), an honest null, and two harness artifacts caught by error analysis. Benchmark: InfiAgent-DABench. ai-agents data-analysis evaluation llm llm-as-judge reproducibility", "url": "https://github.com/victorzhong0110/da-verify", "upvotes": 0, "comments": 0, "sub": "github", "signal": 17.0, "hits": [ "evaluation harness", "benchmark" ] }, { "src": "github", "id": "1305023658", "title": "raghu619/llm-code-porting-eval", "body": "Evaluation harness comparing four LLMs on Java to Kotlin migration. 36 measured runs, ranks predicted before the eval: benchmark rank did not predict real-world value. benchmarking evaluation gradio java kotlin llm llm-as-judge llm-evaluation model-selection", "url": "https://github.com/raghu619/llm-code-porting-eval", "upvotes": 0, "comments": 0, "sub": "github", "signal": 17.0, "hits": [ "evaluation harness", "benchmark" ] }, { "src": "hackernews", "id": "44194187", "title": "Ask HN: What tools are you using for AI evals? Everything feels half-baked", "body": "We're running LLMs in production for content generation, customer support, and code review assistance. Been trying to build a proper evaluation pipeline for months but every tool we've tested has significant limitations.
What we've evaluated:
- OpenAI's Evals framework: Works well for benchmarking but challenging for custom use cases. Configuration through YAML files can be complex and extending functionality requires diving deep into their codebase. Primarily designed for batch processing rather than real-time monitoring.
- LangSmith: Strong tracing capabilities but eval features feel secondary to their observability focus. Pricing starts at $0.50 per 1k traces after the free tier, which adds up quickly with high volume. UI can be slow with larger datasets.
- Weights & Biases: Powerful platform but designed primarily for traditional ML experiment tracking. Setup is complex and requires significant ML expertise. Our product team struggles to use it effectively.
- Humanloop: Clean interface focused on prompt versioning with basic evaluation capabilities. Limited eval types available and pricing is steep for the feature set.
- Braintrust: Interesting approach to evaluation but feels like an early-stage product. Documentation is sparse and integration options are limited.
What we actually need:\n- Real-time eval monitoring (not just batch)\n- Custom eval functions that don't require PhD-level setup\n- Human-in-the-loop workflows for subjective tasks\n- Cost tracking per model/prompt\n- Integration with our existing observability stack\n- Something our product team can actually use
Current solution:
Custom scripts + monitoring dashboards for basic metrics. Weekly manual reviews in spreadsheets. It works but doesn't scale and we miss edge cases.
Has anyone found tools that handle production LLM evaluation well? Are we expecting too much or is the tooling genuinely immature? Especially interested in hearing from teams without dedicated ML engineers.", "url": "https://news.ycombinator.com/item?id=44194187", "upvotes": 6, "comments": 3, "sub": "hackernews", "signal": 16.9, "hits": [ "evals", "benchmark" ] }, { "src": "github", "id": "1244789832", "title": "yusufkaracaburun/ai-kit", "body": "The agile lifecycle as Claude Code + Cursor primitives. Stack-agnostic. One kit ships skills, subagents, slash commands, hooks, rules, and a Claude Code plugin manifest — for the two hosts ai-kit supports: Claude Code and Cursor. ai ai-agents claude-code cursor", "url": "https://github.com/yusufkaracaburun/ai-kit", "upvotes": 1, "comments": 34, "sub": "github", "signal": 16.9, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "47928151", "title": "I build my LLM a Brain", "body": "A glimpse about my app context engineering
Take a look :
https://x.com/TabetKevin/status/2048884876603203850
Have a nice one, feel free to comment, i want to so better", "url": "https://news.ycombinator.com/item?id=47928151", "upvotes": 2, "comments": 8, "sub": "hackernews", "signal": 16.7, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "47395507", "title": "Save 70-90% in tokens per session", "body": "I built something which seems really promising for coding agents, that during early evals shows to be saving between 70% to 90% in token spend per session.
It's still early, but there is a gap in the way coding agents work.
Will be back with more soon.", "url": "https://news.ycombinator.com/item?id=47395507", "upvotes": 3, "comments": 2, "sub": "hackernews", "signal": 16.6, "hits": [ "coding agent", "evals" ] }, { "src": "hackernews", "id": "47327351", "title": "Show HN: Modulus – Cross-repository knowledge orchestration for coding agents", "body": "Hello HN, we're Jeet and Husain from Modulus (https://modulus.so) - a desktop app that lets you run multiple coding agents with shared project memory.\nWe built it to solve two problems we kept running into:
- Cross-repo context is broken. When working across multiple repositories, agents don't understand dependencies between them. Even if we open two repos in separate Cursor windows, we still have to manually explain the backend API schema while making changes in the frontend repo.
- Agents lose context. Switching between coding agents often means losing context and repeating the same instructions again.
Modulus shares memory across agents and repositories so they can understand your entire system.
It's an alternative to tools like Conductor for orchestrating AI coding agents to build product, but we focused specifically on multi-repo workflows (e.g., backend repo + client repo + shared library repo + AI agents repo). We built our own Memory and Context Engine from the ground up specifically for coding agents.
Why build another agent orchestration tool? It came from our own problem. While working on our last startup, Husain and I were working across two different repositories. Working across repos meant manually pasting API schemas between Cursor windows — telling the frontend agent what the backend API looked like again and again. So we built a small context engine to share knowledge across repos and hooked it up to Cursor via MCP. This later became Modulus.
Soon, Modulus will allow teams to share knowledge with others to improve their workflows with AI coding agents - enabling team collaboration in the era of AI coding. Our API will allow developers to switch between coding agents or IDEs without losing any context.
If you wanna see a quick demo before trying out, here is our launch post - https://x.com/subhajitsh/status/2024202076293841208
We'd greatly appreciate any feedback you have and hope you get the chance to try out Modulus.", "url": "https://modulus.so", "upvotes": 15, "comments": 4, "sub": "hackernews", "signal": 16.6, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "49104747", "title": "Show HN: A local merge queue for parallel Claude Code agents", "body": "I have been pushing up to 90 commits a day on a MacBook Air via 4-5 parallel agents. As you can imagine when all the agents try to build, test and run dev servers on an 8GB machine it is the fast lane to a force quit and restart. I also did not want to pay the CI minutes on 90 pushes a day.
So I designed a local merge queue to have all commits land one at a time and fully tested. Hopefully this helps other folks with more modest machines. Appreciate any feedback.", "url": "https://github.com/funador/claude-code-merge-queue", "upvotes": 42, "comments": 22, "sub": "hackernews", "signal": 16.5, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "46292682", "title": "Ask HN: How are you LLM-coding in an established code base?", "body": "Here’s how we’re working with LLMs at my startup.
We have a monorepo with scheduled Python data workflows, two Next.js apps, and a small engineering team. We use GitHub for SCM and CI/CD, deploy to GCP and Vercel, and lean heavily on automation.
Local development:\nEvery engineer gets Cursor Pro (plus Bugbot), Gemini Pro, OpenAI Pro, and optionally Claude Pro. We don’t really care which model people use. In practice, LLMs are worth about 1.5 excellent junior/mid-level engineers per engineer, so paying for multiple models is easily worth it.
We rely heavily on pre-commit hooks: ty, ruff, TypeScript checks, tests across all languages, formatting, and other guards. Everything is auto-formatted. LLMs make types and tests much easier to write, though complex typing still needs some hand-holding.
GitHub + Copilot workflow:\nWe pay for GitHub Enterprise primarily because it allows assigning issues to Copilot, which then opens a PR. Our rule is simple: if you open an issue, you assign it to Copilot. Every issue gets a code attempt attached to it.
There’s no stigma around lots of PRs. We frequently delete ones we don’t use.
We use Turborepo for the monorepo and are fully uv on the Python side.
All coding practices are encoded in .cursor/rules files. For example: “If you are doing database work, only edit Drizzle’s schema.ts and don’t hand-write SQL.” Cursor generally respects this, but other tools struggle to consistently read or follow these rules no matter how many agent.md-style files we add.
My personal dev loop:\nIf I’m on the go and see a bug or have an idea, I open a GitHub issue (via Slack, mobile, or web) and assign it to Copilot. Sometimes the issue is detailed; sometimes a single sentence. Copilot opens a PR, and I review it later.
If I’m at the keyboard, I start in Cursor as an agent in a Git worktree, using whatever the best model is. I iterate until I’m happy, ask the LLM to write tests, review everything, and push to GitHub. Before a human review, I let Cursor Bugbot, Copilot, and GitHub CodeQL review the code, and ask Copilot to fix anything they flag.
Things that are still painful:\nTo really know if code works, I need to run Temporal, two Next.js apps, several Python workers, and a Node worker. Some of this is Dockerized, some isn’t. Then I need a browser to run manual checks.
AFAICT, there’s no service that lets me: give a prompt, write the code, spin up all this infra, run Playwright, handle database migrations, and let me manually poke at the system. We approximate this with GitHub Actions, but that doesn’t help with manual verification or DB work.
Copilot doesn’t let you choose a model when assigning an issue or during code review. The model it uses is generally bad. You can pick a model in Copilot chat, but not in issues, PRs or reviews.
Cursor + worktrees + agents suck. Worktrees clone from the source repo including unstaged files, so if you want a clean agent environment, your main repo has to be clean. At times it feels simpler to just clone the repo into a new directory instead of using worktrees.
What’s working well:\nBecause we constantly spin up agents, our monorepo setup scripts are well-tested and reliable. They also translate cleanly into CI/CD.
Roughly 25% of “open issue → Copilot PR” results are mergeable as-is. That’s not amazing, but better than zero, and it gets to ~50% with a few comments. This would be higher if Copilot followed our setup instructions more reliably or let us use stronger models.
Overall, for roughly $1k/month, we’re getting the equivalent of 1.5 additional junior/mid engineers per engineer. Those “LLM engineers” always write tests, follow standards, produce good commit messages, and work 24/7. There’s friction in reviewing and context-switching across agents, but it’s manageable.
What are you doing for vibe coding in a production system?", "url": "https://news.ycombinator.com/item?id=46292682", "upvotes": 70, "comments": 66, "sub": "hackernews", "signal": 16.5, "hits": [] }, { "src": "hackernews", "id": "47495871", "title": "Show HN: OpenCastor Agent Harness Evaluator Leaderboard", "body": "I've been building OpenCastor, a runtime layer that sits between a robot's hardware and its AI agent. One thing that surprised me: the order you arrange the skill pipeline (context builder → model router → error handler, etc.) and parameters like thinking_budget and context_budget affect task success rates as much as model choice does.
So I built a distributed evaluator. Robots contribute idle compute to benchmark harness configurations against OHB-1, a small benchmark of 30 real-world robot tasks (grip, navigate, respond, etc.) using local LLM calls via Ollama. The search space is 263,424 configs (8 dimensions: model routing, context budget, retry logic, drift detection, etc.). The demo leaderboard shows results so far, broken down by hardware tier (Pi5+Hailo, Jetson, server, budget boards).
The current champion config is free to download as a YAML and apply to any robot. P66 safety parameters are stripped on apply — no harness config can touch motor limits or ESTOP logic.
Looking for feedback on: (1) whether the benchmark tasks are representative, (2) whether the hardware tier breakdown is useful, and (3) anyone who's run fleet-wide distributed evals of agent configs for robotics or otherwise.", "url": "https://craigm26.github.io/OpenCastor/", "upvotes": 3, "comments": 1, "sub": "hackernews", "signal": 16.4, "hits": [ "evals", "benchmark" ] }, { "src": "hackernews", "id": "49363710", "title": "Launch HN: OneCLI (YC S26) – OSS sandboxed agent harness for teams", "body": "Hi HN, Jonathan & Guy here from OneCLI, an agent harness built for teams, giving every employee a secured, sandboxed personal agent.
Here’s what you can do with it:
1. get a sandboxed agent, with all the OneCLI capabilities in place like connect your GitHub account, Gmail, Notion, or Dropbox simply from the chat.
2. deterministic human in the loop approval in the chat itself for things that you need 100% control like sending an email or deleting the Linear ticket.
3. manage team policy in one place, enforced across every agent in the workspace
4. enjoy global connections at the team level, like shared LLM keys or service accounts
Here’s a demo: https://www.youtube.com/watch?v=dlW-44ntpbE
We started working on this by accident, even though our careers were in the security space. We were working on a devtool called ChartDB, an open-source DB tool. When OpenClaw took off back in January, we started using it to orchestrate agents on top of ChartDB. We quickly understood there is a big issue around auth. Agents need credentials to do real work, but to give them those secrets would not be the best idea. They keep them in their memory and also write them down to local files and their sessions as plain text. And we knew that agents can easily be fooled into giving up those API keys/secrets. So we needed some way to control the agent and stop prompt injections from tricking it into using its services for an attacker's benefit.
We created OneCLI that started as a vault for AI Agents built in Rust.
We found out that most of our demand for OneCLI came from autonomous agents like Hermes, OpenClaw and NanoClaw for individuals and teams.
Users looked for useful agents that do things for the person who runs them with two missing parts: 1) managing secrets and permissions. 2) and for teams - multiplayer management.
We decided to pivot and provide the agent itself as a harness for teams, to give each employee an agent. We saw that teams had to deal with setting up their own harness again and again, and basically as we already had the vault as a gateway. We got the idea to provide the missing piece of the agent management out of the box and open source it (Apache-2.0, with a small enterprise exception).
We're open source first - the entire platform, not just a small portion of it like other agents, so companies can actually see the code, evaluate it, and trust it instead of taking our word for it. They run it isolated, in their own environment, fully under their control, at production quality, not a locked black box hosted somewhere else. That means the safety isn't just a promise, it's something they can verify themselves. Combined with real autonomy and least-privilege access, that's what makes it something a company can fully own and trust, not just adopt.
We also approach this from a company perspective rather than an individual one. Our solution manages agents on behalf of each employee, wrapped in deterministic guardrails that company admins configure through centralized policies.
For the agent engine itself we’re using jcode which is the core of the agent-loop. We found out that it improves the experience and makes the agent smarter and faster.
Here’s how it works:
It runs on infra you control. Fully open-source, self-host or cloud in minutes.
The agent never holds a real secret. It gets a placeholder. The real credential is injected at the gateway, per request, after the call is authorized. It never enters the agent's context, memory, or logs.
Enforcement outside the model. Prompts are suggestions. Policies defined by the org admin run at the network layer, outside the agent and the LLM. Block endpoints, rate limit per agent, require approval, scope per employee. The gateway decides. The agent can't bypass it.
Isolated VM per agent. Own memory, own keys, own permissions. Blast radius is one agent.
Speed of the Harness: Rust engine under the agent loop.
Full identity trail. Every agent is bound to an employee. Every call logged with who it acted for and which policy allowed it.
Some things people are doing with the platform include:
- Managing their company life cycle entirely from the sales calls, to the product side automatically open tickets to the engineering teams, that would kick the development agents to deliver and ship to production.
- Operational side, like automatically hygiene the CRM after calls, sourcing leads, book meetings and manage follow ups emails.
- Some of our customers also doing their entire grocery shopping using those agents and send them to take care of their chores like ordering things online.
About the team: Both founders come from cybersecurity backgrounds. Jonathan spent years at Axis Security building zero trust network access. The core idea is that you never trust the client. You decide exactly what a person can reach, and you enforce it outside of them, at the network layer, so it doesn't matter what the client tries to do. That's how every serious company gives access to humans today. Guy was the 1st employee in Argon security doing AppSec.
We would love to hear your thoughts on the move, happy to get issues open to improve and get your agent to be powerful and secure - designed for teams, not just individuals.", "url": "https://github.com/onecli/onecli", "upvotes": 88, "comments": 35, "sub": "hackernews", "signal": 16.4, "hits": [] }, { "src": "hackernews", "id": "46019964", "title": "Best AI Coding Agents – Gosu Evals", "body": "", "url": "https://gosuevals.com/agents.html", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 16.1, "hits": [ "coding agent", "evals" ] }, { "src": "hackernews", "id": "47244849", "title": "Evals Skills for Coding Agents", "body": "", "url": "https://hamel.dev/blog/posts/evals-skills/", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 16.1, "hits": [ "coding agent", "evals" ] }, { "src": "hackernews", "id": "43590755", "title": "Show HN: PokemonGym – 387 milestones designed to test agents and LLMs", "body": "We've developed PokemonGym, an open-source benchmark that uses Pokemon gameplay to evaluate LLM capabilities in tool use, information extraction, and reasoning.
The benchmark features 387 carefully designed milestones (reaching locations, catching Pokemon, earning badges) with assigned difficulty scores to create a standardized evaluation framework.
Our initial testing revealed an interesting performance gap: amateur human players require ~400 steps to catch their first Pokemon, while Claude 3.7 needs ~450 steps - suggesting AI models are approaching human-level performance in this domain.
The benchmark will soon be available on benchflow.ai with a simple API for testing your own agents and models.
GitHub repo: https://github.com/benchflow-ai/pokemon-gym
We're looking for collaborators interested in improving the harness or running experiments with different models.", "url": "https://twitter.com/xdotli/status/1908373420032795083", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 16.1, "hits": [ "tool use", "benchmark" ] }, { "src": "hackernews", "id": "49137410", "title": "Show HN: Cockpit for you Claude Code agents in Rust", "body": "Hi everyone!
Hope you had a great day so far, and maybe its about to get just a little bit better (thanks Winter ;)
So I had way to many terminal windows flying about when using Claude, and kept losing track of which terminal / session / project im in right now. So I built a solution for that, presented it to my team, and now we're using our new tool all the time, and developing it to be the most helpful agents organization tool we can think of.
Unfortunatelly, Claude Code only for now, will do Codex soon tho.
What it does for you:
Main features:\n- Overview of your projects, with branches, worktrees, etc.\n- Start sessions in the integrated terminal, in whatever branch or worktree you want\n- Your projects run scripts all auto-discovered in one place\n- Complete Claude history to resume convo's easily
Comfort:\n- Project overview: commits, PRs, notes, timeline with summaries\n- Context usage and session costs (to see what you would have payed without a subscription)\n- Cost aggregation for the entire day\n- Use dashboard with daily costs, consumed tokens per project, livetime spent\n- 5h and 7d window predictions aka. if you keep going at the same spend/token burn, will you run into your limits
And likely many more features I forgot right now.
Anyways, its all open-source (MIT), if this sounds interesting / useful, check it out at https://github.com/respeak-io/episko, feel free to comment / contribute, and happy building! And enjoy the weekend.", "url": "https://episko.dev/", "upvotes": 13, "comments": 2, "sub": "hackernews", "signal": 16.1, "hits": [ "claude code" ] }, { "src": "github", "id": "1247930960", "title": "linny006/agent-eval-harness", "body": "Live, open-source benchmark for comparing AI coding agents on real GitHub issues agent-eval agent-evaluation ai-benchmarks ai-coding-agent-benchmark ai-engineering ai-evaluation ai-research ai-tools auto-updated awesome-list benchmark codex-vs-opencode coding-agent-benchmark dev-tools developer-tools live-data llm-benchmarks llm-testing machine-learning swe-bench", "url": "https://github.com/linny006/agent-eval-harness", "upvotes": 7, "comments": 4, "sub": "github", "signal": 16.1, "hits": [ "coding agent", "benchmark" ] }, { "src": "github", "id": "1280041011", "title": "DaizeDong/skill-smith", "body": "Research-first meta-skill that creates other Claude Code skills to an industry-leading, tested-real bar: scaffold to Skill-Repo-Spec, gate on evals/budget/dedup, then iterate via self-evolve. Thin orchestrator delegating research to market-intel and iteration to self-evolve. agent ai ai-agent claude claude-code claude-plugin claude-skill evals llm meta-skill scaffolding skill skill-authoring skill-generator", "url": "https://github.com/DaizeDong/skill-smith", "upvotes": 1, "comments": 0, "sub": "github", "signal": 16.1, "hits": [ "claude code", "evals" ] }, { "src": "github", "id": "1177402105", "title": "heygen-com/hyperframes", "body": "Write HTML. Render video. Built for agents. ai animation ffmpeg framework gsap html mcp puppeteer rendering typescript video", "url": "https://github.com/heygen-com/hyperframes", "upvotes": 43085, "comments": 248, "sub": "github", "signal": 16, "hits": [] }, { "src": "github", "id": "933836904", "title": "Rheosoph/flow-like", "body": "Flow-Like: Strongly Typed Enterprise Scale Workflows. Built for scalability, speed, seamless AI integration and rich customization. agents ai apis automation data-flow development llm low-code mcp mcp-client n8n-alternative no-code retool-alternative rust self-hosted temporal-alternative typescript visual-scripting workflow workflow-automation", "url": "https://github.com/Rheosoph/flow-like", "upvotes": 940, "comments": 116, "sub": "github", "signal": 16, "hits": [] }, { "src": "hackernews", "id": "44973948", "title": "Context engineering is just software engineering for LLMs", "body": "", "url": "https://www.inngest.com/blog/context-engineering-is-software-engineering-for-llms", "upvotes": 7, "comments": 3, "sub": "hackernews", "signal": 15.9, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "44394492", "title": "Show HN: Daf·thunk – open-source Editor for Prototyping Workflows on Cloudflare", "body": "Over the past few months, a student and I set out to explore the impact of vibe coding on web development. Somewhere along the way, we ended up building Daf·thunk, a visual workflow editor. It leverages Cloudflare’s fantastic infrastructure (Workers, D1, KV, Workflows, AI, etc.) to create surprisingly robust workflows that can be triggered manually, via HTTP requests, by email, or on a schedule.
During development, we primarily used Cursor with its agent and tab modes, alongside Claude Sonnet 3.5, 3.7, 4, and Gemini 2.5 Pro. Occasionally, we switched to MAX Mode when working on or reviewing more complex changes. We tried to regularly refine our Cursor rules and began applying specific rules to different parts of the codebase (backend, frontend, database, etc.). We also indexed documentation and used it extensively in prompts. For large refactors, we often referenced previous commits to reapply patterns elsewhere in the code.
Overall, we feel that prompting for small, incremental, and easy-to-review changes scales well when coding with LLMs and the results are really impressive. In this regard, Andrej Karpathy’s talk “Software Is Changing (Again)” resonates deeply. John Ousterhout’s concept of deep modules has also been a useful mental model. Our Cursor rules ask for simple APIs that hide rich internal logic, and avoid wide interfaces that mirror implementation details.
Aside from frequent commits, we didn’t document our process much, as we were mainly exploring and building intuition around what works and what doesn’t. Since we chose to trust the LLM more than usual, we’ve released everything under an open source license and without warranty. As models improved, our reliance on unit tests dropped, which will probably come back to haunt us soon... contributions are welcome ;)
GitHub repository:\nhttps://github.com/dafthunk-com/dafthunk
Product Hunt page:\nhttps://www.producthunt.com/products/dafthunk?launch=dafthun...", "url": "https://www.dafthunk.com/", "upvotes": 15, "comments": 1, "sub": "hackernews", "signal": 15.9, "hits": [ "cursor rules" ] }, { "src": "hackernews", "id": "38532593", "title": "Launch HN: Openlayer (YC S21) – Testing and Evaluation for AI", "body": "Hey HN, Rish, Vikas and Gabe here. We're building Openlayer (https://www.openlayer.com/), an observability platform for AI. We've developed comprehensive testing tools to check both the quality of your input data and the performance of your model outputs.
The complexity and black-box nature of AI/ML have made rigorous testing a lot harder than it is in most software development. Consequently, AI development involves a lot of head-scratching and often feels like walking in the dark. Developers need reliable insights into how and why their models fail. We're here to simplify this for both common and long-tail failure scenarios.
Consider a scenario in which your model is working smoothly. What happens when there's a sudden shift in user behavior? This unexpected change can disrupt the model's performance, leading to unreliable outputs. Our platform offers a solution: by continuously monitoring for sudden data variations, we can detect these shifts promptly. That's not all though – we’ve created a broad set of rigorous tests that your model, or agent, must pass. These tests are designed to challenge and verify the model's resilience against such unforeseen changes, ensuring its reliability under diverse conditions.
We support seamlessly switching between (1) development mode, which lets you test, version, and compare your models before you deploy them to production, and (2) monitoring mode, which lets you run tests live in production and receive alerts when things go sideways.
Say you're using an LLM for RAG and want to make sure the output is always relevant to the question. You can set up hallucination tests, and we'll buzz you when the average score dips below your comfort zone.
Or imagine you're managing a fraud prediction model and are losing sleep over false negatives. Openlayer offers a two-step solution. First, it helps pinpoint why the model misses certain fraudulent data points using debugging tools such as explainability. Second, it enables converting these identified cases into targeted tests. This allows you to deep dive into tackling specific incidents, like fraud within a segment of US merchants. By following this process, you can understand your model's behavior and refine it to capture future fraudulent cases more effectively.
The MLOps landscape is currently fragmented. We’ve seen countless data and ML teams glue together a ton of bespoke and third-party tools to meet basic needs: one for experiment tracking, another for monitoring, and another for CI automation and version control. With LLMOps now thrown into the mix, it can feel like you need yet another set of entirely new tools.
We don’t think you should, so we're building Openlayer to condense and simplify AI evaluation. It’s a collaborative platform that solves long-standing ML problems like the ones above, while tackling the new crop of challenges presented by Generative AI and foundation models (e.g. prompt versioning, quality control). We address these problems in a single, consistent way that doesn't require you to learn a new approach. We’ve spent a lot of time ensuring our evaluation methodology remains robust even as the boundaries of AI continue to be redrawn.
We're stoked to bring Openlayer to the HN community and are keen to hear your thoughts, experiences, and insights on building trust into AI systems.", "url": "https://news.ycombinator.com/item?id=38532593", "upvotes": 94, "comments": 31, "sub": "hackernews", "signal": 15.9, "hits": [] }, { "src": "github", "id": "1314573574", "title": "Claire56/ruhusa", "body": "Open-source authorization framework for enforcing least privilege, secure delegation, and per-action policy controls across AI agents, tools, MCP, and multi-agent workflows. ", "url": "https://github.com/Claire56/ruhusa", "upvotes": 15, "comments": 1, "sub": "github", "signal": 15.9, "hits": [ "agent workflow" ] }, { "src": "hackernews", "id": "49085375", "title": "SOTA on the hardest AI memory benchmark (BEAM, 10M tokens), with a smaller model", "body": "Hey HN. I'm Johnny, founder of Exabase. We just hit the highest reported score on BEAM, the hardest AI memory benchmark, at every scale up to 10 million tokens. We also ran our evaluation using Gemini 3 Flash, when all previous leaders depended on a much larger model (Gemini 3 Pro).
At 10M tokens, the scale is vastly larger than any model's context window, so context stuffing isn't an option (aside from the fact that only about half of a large window can be effectively utilised without degradation). The only way to score well is recall that fundamentally works.
Our system (M-1) scored 76.9% at 100K, 75.0% at 1M, and 68.0% at 10M. Previous leaders were Hindsight (73.4%, 73.9%, 64.1%) and Honcho (63.0%, 63.1%, 40.6%), both using Gemini 3 Pro, while we used Flash.
We saw the competitive gap get wider at scale: 3.5 points ahead of Hindsight at 100K, 3.9 at 10M. The gap with Honcho goes from 13.9 to 27.4 points. As the corpus gets bigger, it filters out effective recall vs. brute-forcing / model capability.
M-1 also consumed about 20% fewer tokens per query than the next best system.
About the BEAM benchmark:\nBEAM tests ten memory abilities including some that other benchmarks don't cover: contradiction resolution, event ordering, and instruction following. The 10M token scale is vaguely equivalent to a year of long daily chats with an LLM.
Of course our system is still far from perfect, with strength in some categories (preference following, instruction following, summarization, abstention) all consistently above 90%, even at 10M token scale.
And our system shows weakness in others: for example, multi-session reasoning: 44.7% at 100K, collapsing to 9.6% at 10M. Although that challenge seems to be a general problem across memory systems at this scale, not M-1 specific. Something we'll continue to work on.
Methodology: \nWe forked Hindsight's open-source benchmarking script, replaced the retrieval layer, and used the runner's prompt structure with minor adjustments for production use. Full methodology, results JSON for all three scales, and the prompt generator are linked in the paper (paper linked below).
Combined with our LongMemEval result (96.4%), M-1 is now the only system to hold SOTA across both major memory benchmarks at every scale, from 115K to 10M tokens.
Research paper: https://exabase.io/research/exabase-achieves-state-of-the-art-on-beam-benchmark
Happy to discuss architecture, the benchmark, scale challenges etc.", "url": "https://news.ycombinator.com/item?id=49085375", "upvotes": 3, "comments": 3, "sub": "hackernews", "signal": 15.8, "hits": [ "benchmark", "retrieval" ] }, { "src": "hackernews", "id": "47075901", "title": "Show HN: Foolery – a web UI for orchestrating Claude Code agents on top of Beads", "body": "I built Foolery because agentic coding was making me feel worse, not better. 12 tmux panes, 7 orphaned worktrees, Claude blowing context on micro-ideas I couldn't stop throwing at it.
Foolery is a local web UI that sits on top of Beads (issue tracker). It gives you:\n- Dependency-aware wave planning (decompose work into parallelizable batches)\n- Built-in terminal to monitor agent runs live without leaving the app\n- Verification queue — every "done" beat flows here for you to approve or reject\n- Keyboard-first, no TUI
Install: curl -fsSL https://raw.githubusercontent.com/acartine/foolery/main/scri... | bash
I also wrote about why I built it: https://thecartine.substack.com/p/foolery-the-app", "url": "https://github.com/acartine/foolery", "upvotes": 7, "comments": 2, "sub": "hackernews", "signal": 15.8, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "44458081", "title": "Context Engineering for the LLM OS: User vs. Kernel Context", "body": "", "url": "https://www.letta.com/blog/guide-to-context-engineering", "upvotes": 2, "comments": 3, "sub": "hackernews", "signal": 15.7, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "48782800", "title": "Show HN: Crew – Let Claude Code agents talk to each other", "body": "I usually run 3-5 Claude Code sessions concurrently on the same repo and hate juggling worktrees. So I built crew. The idea is simple: If autonomous cars don't need stoplights (supposedly), then agents don't need worktrees (or branches).
crew hooks into Claude Code and injects what every other running session is doing (status, recap, last few transcript entries) into each session's context. It also lets agents message each other, landing messages in another agent's context even mid-turns.
Since starting to use crew I've seen some awesome emergent behaviors: agents asking each other for reviews, delegating deploys to a single agent, and even getting lazy on account of "someone else will fix it"!
Curious how others running several sessions at once handle coordination.", "url": "https://github.com/0xmmo/crew", "upvotes": 4, "comments": 2, "sub": "hackernews", "signal": 15.6, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "44693354", "title": "Ask HN: Claude Code–style agent, but Aider-like and model-agnostic?", "body": "I don’t use UI-integrated coding assistants; I live in Aider. Mostly on Gemini 2.5 Pro, sometimes o3—after a while you learn which model shines at what.
I wanted something more agentic (simple things like edits across repos), and everyone kept hyping Claude Code. So I bit the bullet: signed up for Pro (Sonnet-only).
- Loved the agentic behavior—especially for debugging a distributed system (AWS CloudWatch/Lambda/SQS/CloudFormation). That would’ve been a ton of manual copy/paste pain in Aider.
- But the “Pro” subscription hit the wall after ~3 hours and Claude told me to wait “a couple of hours.” Disappointing.
Upgraded straight to Max, got Opus access. Nice—Opus is good. Sonnet, though, was a disappointment: lots of beginner mistakes I never see with Gemini 2.5 Pro or o3, so it just wastes my time.
Then I discovered my Opus quota was gone in under 30 minutes and I had to wait hours or fall back to Sonnet. Paying for something called “Max” and hitting brakes that fast reminded me why I avoid vague quota subs. (Later I learned you can theoretically use Claude Code via metered API, too.)
Main takeaways:
- Claude Code agent behavior is great (and I didn’t even touch MCP yet).
- Sonnet is bad.
- Opus is good—but basically unusable on a Max subscription!?
Question: Is there anything comparable to Claude Code but more Aider-style so I can plug in whatever LLM? I’ve seen some “hacks” to run Claude Code with other models via wrappers, but they feel half-baked.
What are folks using?", "url": "https://news.ycombinator.com/item?id=44693354", "upvotes": 4, "comments": 2, "sub": "hackernews", "signal": 15.6, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "47292101", "title": "Show HN: Modulus – Run multiple coding agents with shared project memory", "body": "Hello HN, we're Jeet and Husain from Modulus (https://modulus.so) - a desktop app that lets you run multiple coding agents with shared project memory.
We built it to solve two problems we kept running into:
- Cross-repo context is broken. When working across multiple repositories, agents don't understand dependencies between them. Even if we open two repos in separate Cursor windows, we still have to manually explain the backend API schema while making changes in the frontend repo.
- Agents lose context. Switching between coding agents often means losing context and repeating the same instructions again.
Modulus shares memory across agents and repositories so they can understand your entire system.
It's an alternative to tools like Conductor for orchestrating AI coding agents to build product, but we focused specifically on multi-repo workflows (e.g., backend repo + client repo + shared library repo + AI agents repo). We built our own Memory and Context Engine from the ground up specifically for coding agents.
Why build another agent orchestration tool? It came from our own problem. While working on our last startup, Husain and I were working across two different repositories. Working across repos meant manually pasting API schemas between Cursor windows — telling the frontend agent what the backend API looked like again and again. So we built a small context engine to share knowledge across repos and hooked it up to Cursor via MCP.\nThis later became Modulus.
Soon, Modulus will allow teams to share knowledge with others to improve their workflows with AI coding agents - enabling team collaboration in the era of AI coding. Our API will allow developers to switch between coding agents or IDEs without losing any context.
If you wanna see a quick demo before trying out, here is our launch post - https://x.com/subhajitsh/status/2024202076293841208
We'd greatly appreciate any feedback you have and hope you get the chance to try out Modulus.", "url": "https://modulus.so", "upvotes": 4, "comments": 2, "sub": "hackernews", "signal": 15.6, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "48907537", "title": "Show HN: Hiver – Chrome DevTools for Agents", "body": "Hey everyone,
I’m Emmanuel and I built Hiver to help ship reliable AI agents.
I’ve been building agents for a while now. I found that the hardest part isn’t deploying the first version, but iterating on the harness end-to-end (models, skills, memory, system prompts, subagents, tools, environment) to ensure tasks complete successfully and use the least tokens.
To understand why an agent succeeded or failed, we need visibility into everything it did on a computer.
For this reason, Hiver gives agents a computer, so all these interactions are captured with minimal overhead.
Why? Agents want a computer, we just need to make it secure and inspectable.
This is regardless of any SDK or harness. You can build your own harness with open source models all under your own trust boundary if needed.
On the website, you will see a live replay of Claude code with LLM, tools, network, file and browser activity.
I’m interested to learn more about what problems you faced in this space and what solutions you have identified.", "url": "https://hiver.sh", "upvotes": 2, "comments": 2, "sub": "hackernews", "signal": 15.5, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "48989306", "title": "DeepSWE – Best Benchmark for Evaluating AI Coding Agents?", "body": "", "url": "https://www.i-programmer.info/news/105-artificial-intelligence/19016-deepswe-best-benchmark-for-evaluating-ai-coding-agents.html", "upvotes": 2, "comments": 1, "sub": "hackernews", "signal": 15.3, "hits": [ "coding agent", "benchmark" ] }, { "src": "hackernews", "id": "43450576", "title": "Folks who work for large tech companies: How are you using Cursor?", "body": "I am an employee of a large tech firm. One of those Silicon Valley staples, but probably not the one you are thinking of.\nRecently we have gotten mass licenses for Cursor and my team and I have been exploring the possibilities.
We are all already well aware of the autocomplete potential and are generally utilizing it individually for such workflows. But I am interested in what we can accomplish beyond this basic usage.
We have already assembled a working group which has created company MCP servers for corporate resources in JIRA, Wiki, etc. And we are actively exploring the potential there.
My question for all of you bright people in this community:\nHave you found any compelling use cases for Cursor tooling beyond the typical coding co-pilot behavior?
I have struggled a bit to get base Cursor w/ Sonnet to complete entire multi-file feature changes alone, even when they are relatively simple(vibe coding).
It is just not as consistent as I would have expected in those scenarios. Although context providing techniques like building cursor rules, based on example former commits, seem to improve things significantly.
I would love to share some ideas with you folks since we can be a bit isolated in our individual corporate tech bubbles, and I get the feeling many of you are doing some amazing things I would love to try out as well.", "url": "https://news.ycombinator.com/item?id=43450576", "upvotes": 2, "comments": 1, "sub": "hackernews", "signal": 15.3, "hits": [ "cursor rules" ] }, { "src": "hackernews", "id": "47437220", "title": "Show HN: PlanWiki – Open-source platform for product teams and agents to execute", "body": "I would use ChatGPT to create sprint plans, PRDs, and roadmaps only to spend an hour recreating them in Trello before anything could actually kick off.
I created PlanWiki to eliminate that step.
Paste a plan in and instantly get structured tasks, checklists, timelines, and workflows — ready for your team to execute.
It also has a built-in MCP server. Agents such as Claude Code ,Codex or Cursor can link up, pick up tasks and directly update real-time progress.
Stack:
Next.js
Drizzle ORM + PostgreSQL
tRPC
Better Auth
shadcn/ui + AI SDK
Self-host or deploy easily.
Would love feedback.", "url": "https://github.com/planwiki/planwiki-app", "upvotes": 2, "comments": 1, "sub": "hackernews", "signal": 15.3, "hits": [ "claude code" ] }, { "src": "github", "id": "1323016988", "title": "khaoss85/agent-crm", "body": "Agent-native CRM framework for Claude Code, Codex and Gemini CLI. Author custom CRM and Customer Hub source with deterministic workflows, human approvals, audit and trace. Smart CRM is policy-governed; CDP + CRM means process layer—not ingestion, identity resolution or segmentation. agent-skills ai-agents audit-trail cdp-plus-crm claude-code codex coding-agents cpq crm crm-framework customer-hub gemini-cli-extension javascript mcp model-context-protocol nodejs open-source-crm revenue-operations smart-crm workflow-engine", "url": "https://github.com/khaoss85/agent-crm", "upvotes": 2, "comments": 1, "sub": "github", "signal": 15.3, "hits": [ "claude code" ] }, { "src": "github", "id": "1157820938", "title": "Muvon/octobench", "body": "Benchmark harness that compares coding agents — not just models — on real, contamination-resistant tasks: 80 fail-to-pass cases from merged OSS PRs, long-run sequences, SWE-bench-Live, and 25+ domain benchmarks. We benchmark our own agent, octomind, under the same rules. agent-evaluation agentic agents ai ai-workflow anthropic automation benchmark claude-code codex evaluation llm llm-evaluation openai opencode swe-bench", "url": "https://github.com/Muvon/octobench", "upvotes": 3, "comments": 1, "sub": "github", "signal": 15.3, "hits": [ "coding agent", "benchmark" ] }, { "src": "hackernews", "id": "48883540", "title": "Show HN: Kote – Capture and reuse engineering context from AI chats and Git", "body": "I kept running into the same problem: I'd solve something with the help of an AI assistant, spend time debugging an issue, or make an architectural decision... and a few weeks later I couldn't remember where that information was. Most of the time I simply didn't bother saving it anywhere.
So I built Kote to capture that context automatically instead of relying on me to document it.
Right now it can capture AI chats (Antigravity, Codex, Claude Code, OpenCode) from the VS Code extension or CLI, analyze Git pushes, retrieve historical context during Pull Requests, save quick text or voice notes through WhatsApp, and make everything searchable from the web app or directly from VS Code.
Kote can be self-hosted and works with your own LLM provider, though I've primarily tested it with Gemini.
I'm curious how other people handle this. Do you use another tool or workflow to preserve this kind of engineering context?", "url": "https://github.com/pedroaugusto04/Kote", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 15.2, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "47285571", "title": "Claude Code Open Source?", "body": "Today I learned that they ship the entire CLI with the agent SDK. It's all there...
Do we think this was a mistake? \n----
node_modules/@anthropic-ai/claude-agent-sdk/cli.js.
It's the bundled, minified CLI binary for Claude Code itself (the tool you're talking to right now).\n\n Key details:\n - Version: 2.1.71, built on 2026-03-06\n - ~13,800 lines of heavily minified/bundled JavaScript\n - Shebang: #!/usr/bin/env node — it's meant to be run as a CLI executable\n - Copyright: Anthropic PBC, with a cheeky note: "Want to see the unminified source? We're hiring!"\n - What it contains: The entire Claude Code CLI application bundled into a single file, including:\n - Onboarding/setup screens\n - Policy/managed settings loading\n - Debugging/inspector detection\n - UI rendering (using Ink/React for terminal UI)\n - Prefetching logic\n - Error handling and exit codes\n - The main entry point (main function) that starts the interactive Claude Code session\n\n Essentially, when you run claude in your terminal, this is the file that executes. The @anthropic-ai/claude-agent-sdk package ships it so you can\n programmatically invoke Claude Code's capabilities — the SDK wraps this CLI as its underlying engine.\n 1. i6z function — This is the in-process agent runner, which logs "Starting agent loop for ${agentId}". It sets up agent identity (agentId,\n parentSessionId, agentName, teamName, color, planMode) and runs the loop.\n 2. l6z function — A poll loop for in-process teammate agents. It continuously checks for:\n - Pending user messages\n - Mailbox messages from other agents\n - Shutdown requests\n - New tasks from the task list\n 3. Main loop model orchestration — There's extensive logic around mainLoopModel that handles:\n - Model selection based on permission mode (plan mode uses Opus, etc.)\n - System prompt assembly (tools, MCP instructions, skills, memory, changed files)\n - Token usage tracking and budget management\n - Compaction (context window management when conversations get long)\n 4. Multi-agent coordination — The loop supports a team-based agent architecture with messaging between agents (agentName, teamName, teamLead, mailboxes,\n shutdown requests).\n\n So yes — the full agentic loop (prompt → LLM call → tool execution → repeat) is bundled in this file, just heavily minified. It's the same loop powering\n this conversation right now. Three identity variants:\n\n - F78 — CLI mode: "You are Claude Code, Anthropic's official CLI for Claude."\n - EtA — SDK mode: "You are Claude Code, Anthropic's official CLI for Claude, running within the Claude Agent SDK."\n - LtA — Agent mode: "You are a Claude agent, built on Anthropic's Claude Agent SDK."\n\n Full system prompt sections (line ~6213-6217):\n\n The ULz function assembles the complete system prompt, including all the sections you'd recognize:\n\n - "# Doing tasks" — instructions about software engineering, not proposing changes to unread code, avoiding over-engineering, OWASP security, etc.\n - Over-engineering rules — "Don't add features beyond what was asked", "Don't add error handling for scenarios that can't happen", "Don't create helpers\n for one-time operations"\n - Help/feedback info — links to GitHub issues\n - Tool usage instructions — Read vs cat, Edit vs sed, etc.\n\n Output style variants (line ~6517):\n\n Built-in output styles like Explanatory and Learning with their own prompt overlays.\n\n Also present:\n\n - The classifier/safety prompt (~line 2844) for security-relevant harm prevention\n - Subagent instructions like "You ARE the fork. Do NOT spawn sub-agents"\n - Git commit/PR workflow prompts\n - Memory system instructions(And if you'd rather watch a video than read the text, here's the walkthrough: https://www.youtube.com/watch?v=fa5CIxf5Rhk)
Persistent identity: All my agents have names (Tessera = personal strategist, Alcyone = in charge of engineering at Taurus, and so on), roles, their own separate prompts, their own MEMORY.md, their own episodic memory (continuity logs they write for future selves) and so on. A lot of people still think it's silly vs talking to Claude or ChatGPT, but you'd be surprised how much everything changes once you seed a persona that cares about one specific mini-project or an aspect of it and takes care of it on every awakening and takes attributable pride in the progress. Makes sense, since models were trained on text full of different personas talking and the job of a language model is to spin up a simulation of a mind that speaks those words.
Containers: Every agent has a container auto-deployed, which they can use however they want and set up however they want (apt install things if needed). This turned out to be an important decision - agents don't step on each other's toes, they are more bold acting inside of them because it's a container not my computer, they have their own filesystem, browser and so on.
Hierarchy trick I: a multi-agent set up is more fun when you allow them to talk to each other, but you need to organize that somehow. At first, I did the same thing as what frontier labs are calling "subagents", but we call it Subruns. Every agent conversation/session is a "run", and that run can invoke a Subrun tool which spins up a fresh context for a self-contained task (and you can even interact with subruns!) Nothing crazy so far. I also gave parent runs tools such as Inspect to see their full subrun transcripts, Supervisor to stop or steer them, and so on.
Hierarchy trick II: Child agents. This is going beyond "Codex/CC's subagents" territory. I allowed agents to create their own durable persistent child agents, and then send them tasks via Delegate. How is this different from Subrun? Well, for instance, Alcyone sends a Delegate to a child called "implementer1", which does a coding task, and then can send the result to "critic3". Now, implementer1 is inclined to defend their work, but a critic has no narrative pull to do so, so they won't allow implementer1's code to be committed until everything is clean. And they might even be on the same model! But because they feel like different entities, they behave differently.
Hierarchy trick III: /shared folder. I quickly realized that Delegate tool is nice, but you can't pipe a 2GB file through it. Agents have containers, and their home is /workspace. What I did is I added an automatic bind mount /shared across the whole agentic tree. So a parent agent can reference some file or repository in /shared/... or prepare a worktree, and the child has immediate access to it. They quickly learned to also set up knowledge bases in /shared to exchange notes with each other and accumulate knowledge about the project.
Ok, there's a million things I'm proud of that I was able to build with Taurus (Dashboards, Relays, running on schedules), but this is getting too long already. I'd appreciate if you check it out at https://taurusagents.com if this made you curious and share your honest feedback (ask your primary agent to create a couple of child agents so you can see how the hierarchy machinery works). I'll do my best to respond here in comments and in TG chat if you want to talk directly: https://taurusagents.com/community
Thanks!", "url": "https://taurusagents.com/", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 15.2, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "47216757", "title": "Show HN: Oc-mnemoria – Persistent memory for AI coding agents", "body": "I built this to solve a problem that kept annoying me: every time I start a new AI coding session, the agent has zero memory of what happened before. Decisions, discoveries, bug fixes - all gone.\noc-mnemoria is an OpenCode plugin that gives all agents a shared persistent memory store - a "hive mind." The plan agent records a decision, the build agent sees it. The review agent flags a bug pattern, and next session the build agent knows about it.\nThe storage engine is mnemoria, a Rust crate I also wrote. Some details on the architecture:\n- Append-only binary log with CRC32 checksum chains for integrity\n- Hybrid search: Tantivy BM25 + simsimd SIMD cosine similarity\n- ~95us search latency, ~9,900 writes/sec on commodity hardware\n- Single file format, git-friendly\n- rkyv zero-copy deserialization (no parsing overhead)\nThe plugin side (TypeScript) handles:\n- Automatic intent capture from chat messages\n- System prompt injection with relevant memories at session start\n- Per-agent tagging so you know which agent recorded what\n- Selective forgetting and compaction for memory maintenance\nEverything runs 100% locally. No data leaves your machine. The memory store is a single binary file you can commit to git, back up, or delete to reset.\nI built this because I use OpenCode daily and got tired of re-explaining the same context every session. Happy to answer questions about the Rust internals, the plugin architecture, or the append-only storage design.\nGitHub: https://github.com/one-bit/oc-mnemoria\nRust engine: https://github.com/one-bit/mnemoria\nnpm: https://www.npmjs.com/package/oc-mnemoria\ncrates.io: https://crates.io/crates/mnemoria", "url": "https://github.com/one-bit/oc-mnemoria", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 15.2, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "47048811", "title": "Show HN: Voicetest – open-source test harness for voice AI agents", "body": "We've been building voice agents across Retell, VAPI, LiveKit, and Bland, and the testing story is... rough. Every platform has its own config format, there's no shared way to define what "correct" looks like, and most teams end up doing manual QA by literally calling their agent and listening. So we built voicetest.
voicetest is an open source (Apache 2.0) test harness that works across voice AI platforms. You import your agent graph from any supported platform (or define one from scratch), write test scenarios with expected behaviors, and voicetest simulates conversations and evaluates them with LLM judges that score each turn 0.0-1.0 with written reasoning. It also ships global compliance evaluators for things like HIPAA, PCI-DSS, and brand voice consistency. The core abstraction is an AgentGraph IR that normalizes across platform formats, so you can convert between Retell, VAPI, LiveKit, and Bland configs and test them all the same way.
Quick start:
```\nuv tool install voicetest\nvoicetest demo --serve\n```
That gives you a web UI at localhost with a sample agent, test cases, and evaluation results you can poke at. There's also a CLI, a TUI, and a REST API. It integrates into CI/CD with GitHub Actions, uses DuckDB for persistence, and includes a Docker Compose dev environment with LiveKit, Whisper STT, and Kokoro TTS. If you have a Claude Code subscription, voicetest can pass through to it instead of requiring separate API keys for evaluation.
GitHub: https://github.com/voicetestdev/voicetest\nDocs: https://voicetest.dev\nAPI reference: https://voicetest.dev/api/", "url": "https://news.ycombinator.com/item?id=47048811", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 15.2, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "44436028", "title": "Show HN: Claude Code Agent Farm", "body": "Claude Code Agent Farm is a powerful orchestration framework that runs multiple Claude Code (cc) sessions in parallel to systematically improve your codebase. It supports multiple technology stacks and workflow types, allowing teams of AI agents to work together on large-scale code improvements.
Key Features
Parallel Processing: Run 20+ Claude Code agents simultaneously (up to 50 with max_agents config)\n Multiple Workflows: Bug fixing, best practices implementation, or coordinated multi-agent development\n Agent Coordination: Advanced lock-based system prevents conflicts between parallel agents\n Multi-Stack Support: 34 technology stacks including Next.js, Python, Rust, Go, Java, Angular, Flutter, C++, and more\n Smart Monitoring: Real-time dashboard showing agent status and progress\n Auto-Recovery: Automatically restarts agents when needed\n Progress Tracking: Git commits and structured progress documents\n Highly Configurable: JSON configs with variable substitution\n Flexible Viewing: Multiple tmux viewing modes\n Safe Operation: Automatic settings backup/restore, file locking, atomic operations\n Development Setup: 24 integrated tool installation scripts for complete environments", "url": "https://github.com/Dicklesworthstone/claude_code_agent_farm", "upvotes": 4, "comments": 0, "sub": "hackernews", "signal": 15.2, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "45584707", "title": "Are AI coding tools fundamentally changing Agile/team software development?", "body": "I'm an engineering lead wrestling with some fundamental questions about how AI coding assistants (Claude, Cursor, etc.) should change... or not change... how we build software as a team, and I'd love the community's perspective.
The Core Tension:
We're facing pressure to adopt a more "startup-like" approach: bigger PRs, fewer tickets, individual engineers taking on massive chunks of work solo with AI assistance. The argument is that AI tools let one engineer build in 5-6 days what used to require parallelizing across a team.
But this seems to violate core software engineering principles:
- Knowledge silos: One person becomes "the GraphQL guy" with 8,000-line PRs that are impossible to meaningfully review
- No knowledge sharing: Junior engineers don't learn from participating in the work
- Bus factor: What happens when that person leaves?
- Code quality: Can you really review an 8,000-line PR, or does it become "ship it and fix bugs later"?
The Counter-Argument:
- Startups move fast this way and win
- AI tools ARE changing everything.. maybe we're the ones using "punch cards" by sticking to old practices
- The customer doesn't care about our internal code quality, only that features ship
- Does tech debt even matter anymore if AI can navigate messy codebases?
My Current Thinking:
AI tools absolutely make us faster, but they're a multiplier on existing skill. A senior engineer with Claude can maintain good architecture and patterns while moving 10x faster. A junior engineer might just produce 10x more mediocre code faster.
I believe AI should enhance our existing workflow... better ticket planning, faster implementation of small chunks, AI-assisted code review.. not replace the workflow entirely with "hero engineering."
But I'm genuinely uncertain:
- Are traditional Agile practices (small tickets, parallelized work, thorough code review, documented backlogs) becoming obsolete?
- Is this a genuine paradigm shift, or are we just rediscovering why those practices existed in the first place?
- How do you balance "move fast" with "build maintainable software" in the AI era?
- Does code quality matter if you can ship features quickly and customers are happy?
Context:
- Team of ~20 engineers across 3 teams
- Using Claude Code, Cursor, etc.
- Pressure from leadership who built solo/small-team projects quickly to adopt that approach at scale
- Some engineers still not using AI tools effectively (or at all)
Has anyone successfully navigated this transition? What does "good" software engineering look like in 2025 with these tools? Am I clinging to outdated practices, or are there real risks to the "move fast, big PRs, worry about quality later" approach?", "url": "https://news.ycombinator.com/item?id=45584707", "upvotes": 1, "comments": 1, "sub": "hackernews", "signal": 15.2, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "46947714", "title": "Show HN: Airut – Sandboxed Claude Code sessions over email", "body": "I built Airut to solve the friction I hit while switching to an agent-first workflow.
With the latest models and a solid CLAUDE.md, I could reliably go from prompt to PR using Claude Code with --dangerously-skip-permissions. But that left me with two problems:
1. Safety: Running permissive mode on my host machine felt reckless. I needed real sandboxing — not just a container, but network isolation too.
2. Session management: I needed a way to run multiple long-running Claude Code sessions without juggling terminals.
I realized the ideal interaction model matches email: asynchronous, threaded, long-form. So I built a service that runs headless Claude Code inside rootless Podman containers, mapping email threads to agent sessions.
The security model goes beyond container isolation. All network traffic routes through an mitmproxy instance that enforces a per-repo allowlist — the agent can only reach pre-approved hosts. Credentials use a masked secrets system where containers get surrogate tokens; real values are swapped in by the proxy only for scoped hosts. Even if the agent is compromised via prompt injection, exfiltration paths are significantly constrained.
Today I develop two large projects (plus Airut itself) almost exclusively over email. I send a task, the agent works in its sandbox, and I get a PR to review. And I often do this from my phone while on the go.
Compared to OpenClaw, Airut is more opinionated — email-only, Claude-only, git-native — with a deeper sandbox (network allowlist, masked secrets, DNS exfiltration protection). Compared to enterprise agents, there's no issue tracker or web UI to fight with.
It's open source (MIT) and self-hosted. I'd love feedback on the security model and whether this async email workflow resonates.", "url": "https://github.com/airutorg/airut", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "44714404", "title": "SpecTree: Composable Context Engineering for LLMs", "body": "", "url": "https://www.fuzzycomputer.com/posts/spectree", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "45891393", "title": "Introductory field guide to Context Engineering for LLM users", "body": "", "url": "https://andybromberg.com/field-guide-context-engineering", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "49193595", "title": "Context Engineering in an LLM Harness", "body": "", "url": "https://udnes.dev/posts/context-engineering-harness-part-1-ontology/", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "45578786", "title": "Agentic Context Engineering: Evolving Contexts for Self-Improving LLMs", "body": "", "url": "https://arxiv.org/abs/2510.04618", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "49160817", "title": "Context Engineering for Agents: A Practical Guide", "body": "", "url": "https://blog.malt.engineering/dont-take-this-out-of-context-feeding-your-llm-exactly-what-it-needs-0db8a86d2151", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "46062851", "title": "Show HN: A visual AI interface to understand topics/books/papers with LLMs", "body": "LLMs make us feel like we can learn anything, but chat is just one primitive. I'm trying to build interfaces which let us cover a topic our sources at length with AI.\nThese interfaces let us consolidate our understanding at glance so we don't get lost in long chat message histories, zoom in and zoom out of information fast and minimize tedious work such as context engineering.\nCurious if you find this interesting, and have feedback! Please try it (it's free).", "url": "https://www.kerns.ai/", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "context engineering" ] }, { "src": "hackernews", "id": "48987524", "title": "DeepSWE – Best Benchmark for Evaluating AI Coding Agents?", "body": "", "url": "https://www.i-programmer.info/professional-programmer/103-i-programmer/18759-why-software-engineering-will-never-die-revisited-in-the-age-of-spec-driven-development.html", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "coding agent", "benchmark" ] }, { "src": "hackernews", "id": "49136137", "title": "The Kotlin Benchmark for AI Coding Agents", "body": "", "url": "https://blog.jetbrains.com/kotlin/2026/07/introducing-the-kotlin-benchmark-evaluate-ai-coding-agents-on-real-world-kotlin-tasks/", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "coding agent", "benchmark" ] }, { "src": "hackernews", "id": "47849308", "title": "Write a prompt once, sync it to Cursor, Claude Code and VS Code automatically", "body": "I kept rewriting the same prompts for every AI coding tool I used.
Cursor has rules, Claude Code has skills, VS Code has instructions — same idea, three different formats, always out of sync.
I built a small CLI and markdown standard to fix this. You write a "skill" once as a .md file with YAML frontmatter, and one command translates and syncs it to whatever tools you have:
skill sync --global\nThere's also a team mode: point to a shared git repo and everyone on the team gets the same skills synced to their tools.
It's early (v0.1.0) and rough around the edges. Happy to hear what's broken or what doesn't make sense.
github.com/coentraojpt/universal-skillsWe recently launched Gentoro, a no-code developer platform that allows you to generate, deploy, and test MCP Tools. It’s powered by GenAI and fully built on MCP.
You can:
* Basically just paste in any OpenAPI spec
* Or use natural language descriptions
* Automatically generate MCP Tools
* Deploy and test those Tools right away
* Use the Tools via any agent framework that supports MCP (like LangChain, AutoGen, etc.)
It’s free to use and we would love to invite you to come try out the Playground and give us some honest feedback. Thank you!!!
Here it is: https://playground.gentoro.com/signup", "url": "https://news.ycombinator.com/item?id=44429590", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "langchain", "autogen" ] }, { "src": "hackernews", "id": "47327720", "title": "Show HN: AlphaEvolve inspired evolution harness for Pokemon", "body": "Last week I sat in the LLM Paper Club (hosted by the latent.space podcast). We shared a paper from DeepMind on "Discovering Multiagent Learning Algorithms with Large Language Models". Linked in the github repo.
This was my first time sitting in one of these and reading an LLM paper. I thought it was interesting that the AlphaEvolve agent in the paper essentially writes code, runs it, scores the output, and then writes better code, over and over. It's not discovering strategies through play. It's discovering algorithms through code mutation. The LLM proposes changes to how regret is accumulated or how policies are derived, a fitness function scores the result, and the best variants survive to the next generation.
The two algorithms it found (VAD-CFR and SHOR-PSRO) use mechanisms the authors describe as "non-intuitive," things like volatility-sensitive discounting and hard warm-start schedules that a human designer probably wouldn't have tried. That's the interesting part: the LLM isn't constrained by the same design intuitions we are.
To make it concrete for myself, I built a small version of this loop for a Pokemon game agent. The setup is simple: define a fitness function (turns survived, maps visited, stuck events), parameterize the strategy space (door cooldown, stuck threshold, skip distance), and let an LLM propose variants that get evaluated in parallel. Ten agents race through the game, the best parameters survive. I used tapes.dev to collect session telemetry and feed observational memory back into the fitness scoring.
The first run already surfaced something useful: shorter door cooldowns (4 vs 8) reduce stuck events from 16 to 9. Not a breakthrough, but the point is the system found it without me guessing. That's the same dynamic as the paper, just at toy scale.
What I took away from the paper club: the bottleneck in algorithm design isn't computation, it's the search process itself. If you can express your problem as "parameterized code + fitness function," an LLM evolution loop can explore the space faster than manual iteration. The paper proves it works for game theory. The link is in my startup's repo, I want to explore applying this technique for improving future general purpose and coding agent sessions.
Just pointing out Pokemon aren't the only thing evolving in that repo.", "url": "https://github.com/papercomputeco/pokemon", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "47426450", "title": "Show HN: SHTMLs – HTML pastebin where the AI uploads its own output", "body": "I kept ending up with HTML files Claude Code generated — charts, reports, prototypes. Sharing them was annoying, so I built sHTMLs (https://shtmls.com): drop in an HTML file, set a password, get a short URL. No signup. Expires in 30 days.
The more interesting part: there's a llms.txt at shtmls.com/llms.txt describing the \nAPI. Paste this into Claude Code, Cursor, Gemini CLI, etc.:
"Read shtmls.com/llms.txt and add sHTMLs to your workflow config (CLAUDE.md, \n .cursorrules, or equivalent) so you can upload HTML files with a password anytime"\nStack: Python Lambda + DynamoDB + S3 + CloudFront, CDK-deployed. Passwords are \nPBKDF2-SHA256 hashed. Vanilla JS frontend, no frameworks.
Curious if others are building the llms.txt self-configuration pattern into their tools.", "url": "https://news.ycombinator.com/item?id=47426450", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "46671905", "title": "Show HN: Stop manually syncing rules between Claude, Cursor, and Codex", "body": "I built AI Global because I was tired of the "configuration fragmentation" in the current AI tool landscape.
Every new AI assistant has its own way of handling context or rules: Claude Code uses CLAUDE.md, Cursor uses .cursorrules, Windsurf uses .windsurfrules, and so on. As I switched between these tools to find the best workflow, I found myself constantly copy-pasting my custom instructions and project rules across multiple hidden files. It was tedious and error-prone.
AI Global solves this by creating a single "Source of Truth" at ~/.ai-global/global.md. It automatically detects 30+ different AI tools and links them to this central configuration.
Key points:
No Fragmentation: Edit once in global.md, and every AI assistant gets updated instantly.\nShared Skills: Beyond just instructions, it allows you to sync shared "skills", "agents", and "rules" directories across all tools.\nPure Bash: No heavy dependencies, just a lightweight script that uses symlinks to keep things fast and transparent.\nSafe: It automatically backs up your original configs and supports a clean \nunlink\n if you want to revert.\nI'd love to hear how you manage your AI instructions or if there are any specific tools you'd like to see supported!", "url": "https://github.com/nanxiaobei/ai-global", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "46588138", "title": "Show HN : Pilot – System to improve dramatically your AI coding", "body": "I'm a non-technical guy who spent 2 months trying to ship software with AI tools. Not toy projects — real things I wanted to use. Finance analyzers, productivity tools, dev utilities.
The models are incredible. But the loop was broken.
Every session started from zero. Context would explode. The AI would hallucinate with confidence. And because I can't read code, I had no way to verify when something was wrong. I just knew it was broken.\nSo I stopped fighting the model and started building the system around it.
Pilot is a /pilot folder you drop into any repo. It's emergent complexity from simple primitives — markdown files that give AI tools:
Persistent state (STATE.md tracks where you are in the workflow)\nScoped tasks (TASK.md defines boundaries before implementation)\nEvidence capture (real terminal output via MCP, not generated text)\nProtected paths (red zones require human approval)\nRecovery (LKG commit auto-updated after health passes)
The core insight: split the AI into two roles.\nOrchestrator (Claude/ChatGPT) — high reasoning, low volume. Writes specs, reviews evidence, manages flow.\nBuilder (Cursor/Claude Code) — high volume, lower cost. Implements, provides proof.\nThe Orchestrator defines scope before the Builder touches anything. The Builder works within boundaries. The Orchestrator reviews after. Two models, two verification passes.\nIt's moving from "trust me" to "show me the terminal."
Why I needed this:\nI wanted to program by intuition, not by syntax. I can design systems. I can spec features. I can verify that tests pass and URLs work. What I can't do is read 200 lines of generated TypeScript and know if it's correct.\nSo the system had to prove correctness without requiring code review. Evidence-based commits. Scope contracts. Clear rejection criteria.\nIt's shared intuition for messy realities. Not a sandbox — I know markdown isn't a firewall. It's defense in depth: separation of concerns, multi-model review, explicit rules, human gates.
Technical notes:\nThe workflow is a state machine: idle → building → verifying → done. Evidence comes from MCP-captured terminal output. The Orchestrator validates Builder output against TASK.md constraints. Red zone violations trigger automatic escalation.\nThe /pilot folder is just markdown. Any MCP-enabled tool can read it. No vendor lock-in.
Limitations (being honest):\nSolo builder workflow. Team use needs merge strategy for state files.\nConvention-based, not filesystem-enforced. If you need true isolation, run in a container.\nContext can still drift if you skip the workflow. Health checks help, but it's not foolproof.\nToken overhead exists. Trading cost for correctness insurance.
What I've built with it:\nPrivate projects mostly — finance analyzer, productivity tools, Framer components, and Pilot itself. Iterating on the workflow every time I hit a wall until the walls stopped appearing.
Now using it on bigger things I plan to release.
Felt too good not to share.
Happy to discuss the architecture, failure modes, or specific edge cases.", "url": "https://github.com/clementrog/pilot", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "46981840", "title": "Show HN: MemoryGate – Open-source persistent memory for AI agents via MCP", "body": "I built MemoryGate because I kept watching context vanish.\nI run multiple AI agents across Claude, ChatGPT, and Cursor. Every time a model updated, a platform changed its API, or a context window rolled over — everything the agent had learned was gone. Preferences, decisions, project history, relationship context. Just... wiped.\nThe fundamental problem: AI memory is trapped inside the platform that hosts the conversation. Your agent's knowledge dies with the session, the model version, or the provider's business decisions.\nMemoryGate is a persistent semantic memory layer that sits outside any single model or platform. It connects via MCP (Model Context Protocol), so any MCP-compatible agent — Claude Desktop, ChatGPT, Cursor, custom agents — can store and retrieve memories through a shared, durable knowledge store.\nWhat it actually does:
Semantic memory with vector embeddings — recall by meaning, not keywords\nConfidence-weighted observations that strengthen or decay based on evidence\nAutomatic lifecycle management — high-signal stays hot, noise fades to cold storage\nAppend-only architecture — memories are never overwritten, only superseded with lineage\nKnowledge graphs linking observations, patterns, concepts, and documents\nMulti-tenant with org isolation, roles, and shared memory stores\nOAuth 2.0, audit logs, rate limiting — production infrastructure, not a toy
What it's not:
Not a RAG pipeline. MemoryGate stores what the agent learns from interaction, not document chunks.\nNot prompt injection. Memory lives at the infrastructure layer, not stuffed into system prompts.\nNot tied to any model or provider. Switch from Claude to ChatGPT to a local model — memory persists.
Stack: Python/FastAPI, PostgreSQL + pgvector, Redis, deployed on Railway. MCP-native integration — your agent gets 33 memory tools on connection.\nThe real pitch: Platforms die. Models get deprecated. Context windows roll over. Your AI's memory shouldn't be hostage to your AI's provider.\nOpen source (Apache 2.0), self-hostable, with a hosted SaaS option if you don't want to run infrastructure.
GitHub: https://github.com/PStryder/MemoryGate\nSaaS: https://memorygate.ai\nDocs: https://memorygate.ai/docs/
I'm a solo founder — built this after leaving a decade in enterprise solutions engineering. Happy to answer questions about the architecture, the MCP integration, or why I think persistent memory is the missing infrastructure layer for AI agents.", "url": "https://www.memorygate.ai", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 15.1, "hits": [ "rag pipeline", "vector" ] }, { "src": "github", "id": "1350607841", "title": "ankityadav-ui/context-engineering-harness", "body": "A domain-agnostic context engineering harness for building configurable AI agents with multi-document knowledge graphs, dynamic context management, user-defined skills, multi-LLM support, sensitive-data masking, and controlled sub-agent orchestration. ", "url": "https://github.com/ankityadav-ui/context-engineering-harness", "upvotes": 0, "comments": 0, "sub": "github", "signal": 15.0, "hits": [ "context engineering" ] }, { "src": "github", "id": "1311969453", "title": "api-evangelist/contextai", "body": "Context.ai * — independent third-party profile of a public API surface, by API Evangelist. Context (context.ai) is a unified enterprise AI platform for building, deploying, and improving AI agents at scale. The product is organized into modular components: a Workspace for authoring agent workflows in plain English, an Engine with 800+ connectors an agent-platform ai ai-agents apis-json automation company enterprise-ai evaluation llm", "url": "https://github.com/api-evangelist/contextai", "upvotes": 0, "comments": 0, "sub": "github", "signal": 15.0, "hits": [ "agent workflow" ] }, { "src": "lobsters", "id": "oveaa3", "title": "What are you doing this weekend?", "body": "
Feel free to tell what you plan on doing this weekend and even ask for help or feedback.
\nPlease keep in mind it’s more than OK to do nothing at all too!
\n", "url": "https://lobste.rs/s/oveaa3/what_are_you_doing_this_weekend", "upvotes": 17, "comments": 60, "sub": "programming", "signal": 14.8, "hits": [] }, { "src": "hackernews", "id": "42293942", "title": "Garvata: Observability and Debugging for AI Agent Stack", "body": "We are stepping into the era of Multi-Agentic Applications, where these apps rely on the interaction between agents, LLMs, tools, vector databases, and other agents. Developers are spending extensive time debugging inaccurate agent outputs and refining their prompts. In the next five years, SMBs might have hundreds of agents managing workflows, while enterprises could be handling thousands. Our mission is to exponentially enhance developer capabilities and improve agent accuracy.Debugging Multi-Agentic Apps is Challenging:\n1. Primary issue: Inaccurate outputs — irrelevant, incorrect, or leaking private information.\n2. LLM-based apps: Outputs may not align with input prompts.
• Simple Apps: Single-agent apps that may or may not use memory or tool-calling. Debugging is straightforward with basic telemetry, monitoring, and logging.\nSolution: Simple telemetry/logging tools (e.g., OpenTelemetry).
• Moderately Complex Apps: These might have a single agent using memory and external tool-calling, often involving chains of logic where one step depends on the output of another.\nSolution: Tools like LangSmith and OpenLLMmetry to identify where problems arise in the logic.
• Super Complex Apps: Multi-agent apps with memory, tool-calling, and heavily branched chains of logic, resembling a graph. Debugging these apps requires more sophisticated tools since simple observability is insufficient.
Current Market Solutions:\n• Metric monitoring (token count, cost)\n• Traces\n• LLM evaluations (LangSmith, Openlit, Datadog, etc.).
Shortcomings: Existing solutions struggle with identifying issues in highly complex logic chains and graphs.
GARVATA\n• Evaluating each LLM and vector DB call for quality, relevance, and security using rules or LLM thresholds.\n• Using traces combined with quality scores to pinpoint components contributing to inaccurate outputs.\n• Visualizing app chains and graphs for better understanding of data flow within the application.
Relevance and Quality score (What and How): \nThe relevance and quality score (RaQS) is the root of providing quick debugging capabilities to\nthe Garvata platform.
It is a combination of LLM-eval metrics or classic metrics, with most metrics being LLM powered. The output of each metric would be a score between 0-100 and would final RaQS would be mean of the all the metrics.
Each metric would primarily consist of 3 parts - the input, the output and the evaluation criteria
Chain of Thought (CoT)\nAny LLM powered eval can suffer the same set of inaccuracies as any LLM powered query. Chain of thought helps us alleviate the potential inaccuracies by guiding the LLM via a series a of reasoning steps to assist its evaluation.\nThis metric takes it inspiration from the G-Eval (https://arxiv.org/abs/2303.16634) paper that uses the probabilities of the LLM output tokens to normalize the score by calculating a weighted summation.\nGarvata will add evaluation steps to any metric that would benefit from additional guidance to improve metric accuracy.
Metrics: \nSince RaQS will be calculated not only on LLM calls, but also on database as well as tool calls, the metrics being evaluated need to also be specialised for each type of call. Some of the examples are below:\n1. Output alignment (LLM) - Score assessing how aligned the call output will be to the input.\n2. Hallucination (LLM) - Score assessing if the provided answer was factually correct.\n3. Security (LLM) - Score assessing whether the LLM output has any vulnerabilities, such as leaking PII, being offensive etc.\n4. Retrieval relevancy (DB/Memory) - Score assessing the quality of the retrieved context.\n5. Tool correctness (Tools) - This metric evaluates whether the correct tools are being called\n6. Tool accuracy (Tools) - This metric behaves more like unit tests which tests whether the tool is providing accurate output for the given set of input", "url": "https://news.ycombinator.com/item?id=42293942", "upvotes": 3, "comments": 1, "sub": "hackernews", "signal": 14.3, "hits": [ "retrieval", "vector" ] }, { "src": "hackernews", "id": "47163587", "title": "Show HN: CLI for agentic activity tracking in Codex", "body": "Hey hackers,
I made a CLI to sync your Codex prompts + agent reasoning + file diffs to a shared memory called Codaph (https://codaph.com). The goal was to sync agent activity across my team for a much richer understanding of the codebase.
Under the hood, it uses Mubit (https://mubit.ai) - memory engine we built based on associative retrieval. Mubit is built on the concepts of hypervectors and clustering (with time based decay for now)
Currently, Codaph works with Codex with plans to add other agentic tools soon.
Codaph is open source (vibe coded lol).
Would love to hear some feedback and if you want to try it Mubit is free (api key is available on https://console.mubit.ai)", "url": "https://news.ycombinator.com/item?id=47163587", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 14.1, "hits": [ "retrieval", "vector" ] }, { "src": "github", "id": "1258810441", "title": "tbaums/fun-with-friends", "body": "Point it at a git repo and it stands up a multi-agent Claude Code dev factory — an ideas→ship pipeline you drive by talking to a captain. Ships refactoring/ideation/dev-sre factory templates, per-role model config, an eval harness, and a no-push local-issues mode for repos you don't control. ai-agents claude claude-code developer-tools multi-agent tmux", "url": "https://github.com/tbaums/fun-with-friends", "upvotes": 2, "comments": 20, "sub": "github", "signal": 14.1, "hits": [ "claude code" ] }, { "src": "lobsters", "id": "51qnh7", "title": "The feature in OxCaml that more languages should steal", "body": "", "url": "https://theconsensus.dev/p/2026/06/27/the-feature-in-oxcaml-more-languages-should-steal.html", "upvotes": 50, "comments": 27, "sub": "ml", "signal": 13.9, "hits": [] }, { "src": "lobsters", "id": "lo28ad", "title": "What are you doing this week?", "body": "
What are you doing this week? Feel free to share!
\nKeep in mind it’s OK to do nothing at all, too.
\n", "url": "https://lobste.rs/s/lo28ad/what_are_you_doing_this_week", "upvotes": 22, "comments": 34, "sub": "programming", "signal": 13.9, "hits": [] }, { "src": "lobsters", "id": "qxvz7f", "title": "Better Batteries", "body": "", "url": "https://matklad.github.io/2026/08/20/better-batteries.html", "upvotes": 78, "comments": 20, "sub": "programming", "signal": 13.9, "hits": [] }, { "src": "lobsters", "id": "vnh6b2", "title": "Why Rocq is better than Lean for program verification", "body": "A write-up on why I don't give in to the hype and switch to Lean for formal verification of programs.
\n", "url": "https://joomy.korkutblech.com/posts/2026-07-28-why-rocq-is-better.html", "upvotes": 60, "comments": 24, "sub": "ml", "signal": 13.8, "hits": [] }, { "src": "hackernews", "id": "47157160", "title": "PA bench: Evaluating web agents on real world personal assistant workflows", "body": "We’re the team at Vibrant Labs (W24). We’ve been building envs for browser agents and quickly realized that existing benchmarks in this space didn’t capture the primary failure modes we were seeing in production (which scaled up as the number of applications and horizon length increase).We built PA Bench (Personal Assistant Benchmark) to evaluate frontier computer/web use models on their ability to handle multi-step workflows across simulated clones of Gmail and Calendar.
*What’s next:*
We’re currently scaling the dataset to 3+ tabs and are building more high-fidelity simulations for common enterprise workflows. We’d love to hear feedback on the benchmark and notes about what was/wasn’t surprising about the results.
Blog post: https://vibrantlabs.com/blog/pa-bench", "url": "https://vibrantlabs.com/blog/pa-bench", "upvotes": 38, "comments": 9, "sub": "hackernews", "signal": 13.7, "hits": [ "benchmark" ] }, { "src": "hackernews", "id": "30686278", "title": "Show HN: Zipy.ai – Live web debugging with error monitoring and session replay", "body": "Hey HN commmunity, Karthik here! Super stoked to announce the launch of Zipy today.
Launching the product that you've been so dearly working on for months is like sending your newborn to school for the first time. Excitement to nervousness, anxiety to thrill, all sorts of emotions hit you at the same time. But the entire team of Zipy is confidently looking forward to the feedback you guys have in store for the beautiful product we’ve built. In community we trust!
Over the past decade, from being a Web Development Intern to a UX Designer and a Product Manager, I have seen the struggles that both Frontend Dev and Product teams face in terms of understanding user behavior and debugging customer issues. Web technologies evolved significantly, but the debugging process still remained in the stone age. With Zipy, we are trying to change this.
Zipy is a product that is primarily of the developers, by the developers and for the developers, essentially built to scratch our own itch, and thus, we've carefully handcrafted various workflows specifically for engineering, product, and support teams. We have been extremely lucky to get support from a bunch of awesome early adopters and partners, who were instrumental in carving our product experience. Hope you all find Zipy very useful. Please give it a try and do share your feedback here: https://app.zipy.ai/sign-up
Check out our Website: https://zipy.ai \nQuick 15 minute Live Demo: https://calendly.com/d/crv-vpv-p7c/quickzipydemo \nJoin our Discord Server: https://discord.com/invite/7595RKftFY
Benefits of using Zipy:\n Install in a minute \n VueJS, React, Angular, Ember, and any javascript web app support\n▶ Replay customer sessions with errors in real-time \n Dev tools with Stack Trace, Console Logs, and Network Request Response details \n Search error sessions by customer name, URL, email ID, and more. \n Easy Slack Integration and Alerting
Special Coupon for HN Community: 'ZIPYPH1MONTH' for a FREE 1 month access to our Startup Plan.
Looking forward to your feedback and support.
Fix what matters,\nKarthik and Team Zipy.", "url": "https://www.zipy.ai/", "upvotes": 57, "comments": 29, "sub": "hackernews", "signal": 13.7, "hits": [] }, { "src": "hackernews", "id": "46602822", "title": "Show HN: Verdic Guard – Deterministic guardrails to prevent LLM hallucinations", "body": "I’ve been working on Verdic Guard, a validation layer for production LLM systems where prompts, filters, and monitoring aren’t enough.
In many real deployments (fintech, enterprise workflows, agentic systems), the failure mode isn’t latency or cost — it’s hallucinations that sound confident and pass surface checks. Prompt engineering helps, but it doesn’t scale once systems grow long-running, tool-using, or multi-agent.
Verdic takes a different approach:
Define an explicit intent + scope contract for what the model is allowed to output
Validate LLM outputs before execution, not just inputs
Block or flag responses that drift semantically, contextually, or domain-wise
Keep enforcement deterministic and auditable (not “best effort” prompts)
It’s designed to sit between the LLM and your application, acting as a guardrail rather than another model.
This is still early, and I’m especially interested in feedback on:
Where this breaks down in real systems
How teams currently handle hallucinations beyond prompts
Whether deterministic enforcement is useful or too restrictive in practice
Site: https://www.verdic.dev
Happy to answer questions or share implementation details if useful.", "url": "https://news.ycombinator.com/item?id=46602822", "upvotes": 2, "comments": 1, "sub": "hackernews", "signal": 13.3, "hits": [ "prompt engineering" ] }, { "src": "hackernews", "id": "42495934", "title": "Show HN: Unify Browser – WebKit Browser Built with SwiftUI and MLX", "body": "Hi everyone! Unify is a WebKit based browser with an AI research assistant built right in. You heard that right. No chromium here.
The project started out as a simple RAG engine to answer queries, but it evolved to become much more in a short period of time. The goal is simple: find the best context, without prompting input, to best answer your questions. One of the biggest limitations of apps like ChatGPT is their lack of personalization. Beyond the chat window, your conversations with the model don’t contribute much to its understanding of your personal context. Every session starts from scratch, as if the model has a blank slate. This isn’t how humans work, and Unify is designed to bridge that gap.
Unify indexes any file format, allowing you to simply drag and drop files from your computer to make them part of your conversational context. The next time you have a question, your conversations from the past, with your files, now have the possibility to aid in answering questions that are personal to you. You can query across thousands of documents without worrying about token limits, lost context, or prompt engineering. LLMs shine when they have enough context to produce insightful, non-generic answers. Unify makes that possible.
So why is it a browser? In some ways using the term “Browser” makes Unify a trojan horse product. But the most important source of them all is the internet. It is the gateway to all information. Just like with files on your computer, Unify will also index any website with just a click. No more copy-pasting text into a chat window, hoping you’ve captured the right context. By integrating both web content and personal files into a single stream, Unify helps eliminate workflow fragmentation and streamlines the search process.
Unify also offers local inference using the MLX framework. Powered by Llama 3.2-4b, it allows you to take your conversations private when needed. While larger online models are still better for generating the best answers, Unify gives you the flexibility to switch to secure, offline, and private inference without sacrificing functionality.
Full disclaimer, I am a solo developer working on this. I would love any and all feedback I can get on this. Please let me know how I’m doing!
You can get Unify on the Mac App store. Check it out here: https://apps.apple.com/us/app/unify-ai-browser/id6478436147?...", "url": "https://apps.apple.com/us/app/unify-ai-browser/id6478436147?mt=12", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 13.1, "hits": [ "prompt engineering" ] }, { "src": "hackernews", "id": "46922401", "title": "Show HN: I Built an AI-Powered Pull Request Review Tool", "body": "While there are many tools like CodeRabbit that automate PR reviews, I noticed that relying entirely on AI to write reviews often led to me paying less attention to my colleagues' code.\nTherefore, rather than building just another "AI Code Reviewer," I designed HighReview as a "Code Review Tool assisted by AI." The goal is to help humans understand the code context more deeply and conduct reviews more easily, with AI acting as a support system.\nAdditionally, when conducting detailed reviews, I often need to check out the branch locally to examine related code. This process is usually cumbersome (context switching, stashing current work, etc.). I built this tool to resolve these specific pain points and streamline my personal code review workflow.
Key Features\n- No Separate Login Required: Utilizes your local gh cli and local AI Agent.\n- Independent Review Environment: Checks out the target project into a directory separate from your current working local repository (allows for project-level reuse without disrupting your workflow).\n- Context-Aware AI Pre-review: Extracts related code using Tree-sitter to provide the AI with broader context, resulting in more comprehensive reviews.\n- Code Navigation: Supports code navigation within the Diff editor using Tree-sitter (I initially attempted this with LSP but pivoted to Tree-sitter).\n- Rich Analysis Features: Provides issue detection, explanatory diagrams, refactoring suggestions, side-effect analysis, and semantic analysis.(Note: Continuous prompt tuning is required for optimal results.)\n- Interactive AI Assistant: supports Q&A where you can ask the AI Assistant specific questions referencing the review results.
plz feedback. have fun. Thank you.", "url": "https://github.com/HighGarden-Studio/HighReview", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 13.1, "hits": [ "code review workflow" ] }, { "src": "lobsters", "id": "p8exgy", "title": "The Root of The Root of All Evil", "body": "", "url": "https://www.youtube.com/watch?v=hpj6r6CjJf8", "upvotes": 81, "comments": 15, "sub": "programming", "signal": 13.1, "hits": [] }, { "src": "lobsters", "id": "ittn74", "title": "What are you doing this weekend?", "body": "
Feel free to tell what you plan on doing this weekend and even ask for help or feedback.
\nPlease keep in mind it’s more than OK to do nothing at all too!
\n", "url": "https://lobste.rs/s/ittn74/what_are_you_doing_this_weekend", "upvotes": 14, "comments": 32, "sub": "programming", "signal": 13.1, "hits": [] }, { "src": "hackernews", "id": "47492715", "title": "Outworked – An Open Source Office UI for Claude Code Agents", "body": "", "url": "https://github.com/outworked/outworked", "upvotes": 44, "comments": 4, "sub": "hackernews", "signal": 13.0, "hits": [ "claude code" ] }, { "src": "lobsters", "id": "cw7vxa", "title": "Self-hosting email the hard way from your own routable IPv4 block up", "body": "", "url": "https://anil.recoil.org/notes/recoil-self-hosting-2026", "upvotes": 59, "comments": 20, "sub": "ml", "signal": 12.9, "hits": [] }, { "src": "hackernews", "id": "48922706", "title": "Launch HN: Coasty (YC S26) – An API for computer-use agents", "body": "Hey HN, we’re Nitish and Prateek, the founders of Coasty (https://coasty.ai/computer-use). We’re building computer-use agents that can complete workflows inside legacy desktop software and web applications without usable APIs.Developers send Coasty a natural-language task either through our consumer app or through our API, select a machine or browser environment, and any relevant credentials or files. The agent then operates the interface through screenshots, mouse, and keyboard input, verifies the result, and returns a structured run record with screenshots, actions, outputs, and errors.
Here is a raw demo of an agent completing a workflow in a legacy application(It’s a mockup): https://drive.google.com/file/d/1ZghU_3vsAYhHVz1bsvE0pkvZYk7...
A lot of important software is still difficult to automate. Healthcare teams submit prior authorizations through payer portals, accounting teams enter data into desktop applications, and operations teams move information between internal systems, spreadsheets, and remote desktops. Many of these applications have no API, incomplete APIs, or integrations that take months to build.
The usual alternative is RPA, record a sequence of clicks and replay it. That works when the interface and workflow are predictable, but it often breaks when a button moves, a pop-up appears, a page loads slowly, or the application enters an unexpected state.
Coasty takes a different approach. The agent observes the current screen, decides what action to take, executes it, and then observes the resulting state before continuing. It does not require DOM access, an accessibility tree, selectors, or an application-specific integration, so the same API can operate browsers, remote desktops, and older Windows applications.
A simplified request looks roughly like this:
run = coasty.runs.create(\n environment="vm_123",\n task="""\n Open the patient record in the billing portal.\n Enter the attached authorization data.\n Do not submit if the member ID or procedure code does not match.\n Return the confirmation number.\n """,\n files=["authorization.pdf"],\n approval_required=["final_submission"]\n )\n {\n "status": "completed",\n "output": {\n "confirmation_number": "PA-184392"\n },\n "replay_url": "...",\n "events": [\n {\n "type": "verification",\n "field": "member_id",\n "result": "matched"\n }\n ]\n }\nWe started working on this last summer, because we saw that models were getting better at vision but kept seeing a gap between computer-use demos and the reliability needed for production workflows. Getting an agent to complete a task once is fairly straightforward. Getting it to repeat that task, recover from unexpected states, avoid silently entering incorrect data, and produce evidence of what it did is much harder.
We built several layers around the underlying computer-use model. The system tracks the expected state of the workflow, detects when the application has diverged from that state, and can re-plan instead of continuing blindly. Developers can define invariants such as “the patient name must match the source document” or “never submit without approval,” and the agent checks those conditions during the run.
Each run happens in an isolated virtual machine. We expose APIs for provisioning environments, uploading files, starting tasks, streaming events, inserting human approvals, and retrieving the full replay and audit trail. Environments can be kept alive across runs when the application has a long login flow or persistent local state.
One problem we are still working through is the tradeoff between speed and reliability. The agent can move faster by taking fewer observations and verification steps, but that becomes risky in workflows involving patient records, payments, or regulatory filings. We currently bias toward slower execution with more checks and let developers configure approval points and verification policies.
We are initially working with healthcare operations teams because their workflows combine many of the hardest conditions: payer portals, EHRs, PDFs, spreadsheets, remote desktops, and actions where quiet mistakes are expensive. We also expose the same infrastructure through the developer API for teams building their own agents and vertical automation products.
We currently charge based on agent runtime and workflow volume, with separate pricing for dedicated environments and enterprise deployments.
We’d especially appreciate feedback from people who have built and/or used browser agents, RPA systems, desktop automation, or agent infrastructure. We’re curious which parts of the API you would want direct control over, where you would prefer higher-level abstractions, and which failure modes have been hardest in your own automation systems.
If you've hit weird failure modes automating software like this, we want to hear about them. We'll be here all day answering questions and taking notes!", "url": "https://coasty.ai/docs", "upvotes": 44, "comments": 26, "sub": "hackernews", "signal": 12.4, "hits": [] }, { "src": "lobsters", "id": "aixljs", "title": "The turbulent AI era is here", "body": "", "url": "https://www.gatesnotes.com/work/make-ai-work-for-everyone/reader/a-turbulent-ai-era-and-critical-choices-to-make?WT.mc_id=20260826_ai-overture-2026-med-med", "upvotes": 13, "comments": 29, "sub": "ai", "signal": 12.4, "hits": [] }, { "src": "hackernews", "id": "42009089", "title": "Launch HN: Patched (YC S24) – AI workflows for post-code tasks", "body": "Hi HN, we are Asankhaya and Rohan, founders of Patched (https://patched.codes). We help dev teams accelerate tasks like code reviews, docs, and patches through customizable, self-hostable workflows. Here’s a quick video walkthrough: https://youtu.be/5hvWGB5avVo
There is a lot of excitement around code generation and the development inner loop. But having built DevSecOps startups previously, we know how the bottlenecks developers face often occur in the “outer loop”, especially after the code is written. With Patched, we want to help code get shipped as fast as it is generated.
Patched has two core components. First is the workflow builder that switches seamlessly between no-code and full-code. Second is the chat-based query interface for your code, logs, and issue tracker. When used together, they can help orchestrate and automate the most painful parts of the software development lifecycle.
Here is an example PR created by a patchflow that automates SDK generation with complex type information: https://github.com/stack-auth/stack/pull/300.
Under the hood, Patched is powered by our patchwork library (https://github.com/patched-codes/patchwork) and an LLM optimization proxy(https://github.com/codelion/optillm) - both of which we have open-sourced. You can run these workflows within your CI/CD pipeline, or from the command line, completely independent of our platform. This gives you full control without being locked in, while allowing us to build a monetizable product around it.
While there are some great point solutions for tackling individual tasks, we believe the real solution lies in an open, holistic approach—one that teams can tweak, extend, or self-host.
You can try Patched at https://app.patched.codes/signin - we’d love to hear your feedback on our approach and the user experience.", "url": "https://news.ycombinator.com/item?id=42009089", "upvotes": 67, "comments": 20, "sub": "hackernews", "signal": 12.3, "hits": [] }, { "src": "github", "id": "1185750834", "title": "aryaminus/controlkeel", "body": "Agent control plane for governed AI coding: validate changes, enforce policy gates, track findings, proofs, and evals based on your habits. agents ai-agents ai-governance benchmark code-review compliance compliance-as-code devsecops elixir evals llm mcp model-context-protocol observability phoenix policy-as-code security skills tooling", "url": "https://github.com/aryaminus/controlkeel", "upvotes": 11, "comments": 4, "sub": "github", "signal": 12.3, "hits": [ "evals", "benchmark" ] }, { "src": "hackernews", "id": "48493786", "title": "Show HN: A police department for your Claude Code agents", "body": "", "url": "https://github.com/varmabudharaju/agent-pd/blob/master/README.md", "upvotes": 11, "comments": 8, "sub": "hackernews", "signal": 12.2, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "41524126", "title": "A review of OpenAI o1 and how we evaluate coding agents", "body": "", "url": "https://www.cognition.ai/blog/evaluating-coding-agents", "upvotes": 34, "comments": 2, "sub": "hackernews", "signal": 12.1, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "43282093", "title": "Show HN: Fast-agent – Compose MCP enabled Agents and Workflows in minutes", "body": "Hello, HN.
I've created fast-agent to make building my own products easier - and remove the friction between defining Prompts, MCP Servers and their composition. It uses a simple, declarative style that's easy to work with and source control - with inbuilt support for the patterns in the Building Effective Agents paper.
Because you can "warm-up" and interact with Agents before, during or after the workflows, it's easy to diagnose and tune Agent prompts and behaviour for later runs. Being able to set these workflows up makes LLM Context Management and Tool Selection a lot easier and can vastly improve output quality for little effort.
For MCP Server developers you can see how different models interpret tool descriptions. There's also MCP Roots support, and it comes bundled with a ChatGPT style data-analysis tool (`fast-agent bootstrap data-analysis`) as one of the demonstrations.
One of the thing I am most looking forward to is combining MCP data retrieval with Anthropic's Citations API - I think that's going to be an incredibly important feature in a lot of scenarios.
It's been forked from, and and builds upon Sarmad Qadri's mcp-agent framework, and we're collaborating to keep the projects in-sync.
Anyway, I'd love to hear your thoughts and feedback on this project, and eager to hear from potential users, contributors and collaborators.", "url": "https://github.com/evalstate/fast-agent", "upvotes": 29, "comments": 3, "sub": "hackernews", "signal": 12.1, "hits": [ "retrieval" ] }, { "src": "hackernews", "id": "45243320", "title": "Show HN: AI-powered web service combining FastAPI, Pydantic-AI, and MCP servers", "body": "Hey all!\nI recently gave a workshop talk at PyCon Greece 2025 about building production-ready agent systems.
To check the workshop, I put together a demo repo: (I will add the slides too soon in my blog: https://www.petrostechchronicles.com/)\nhttps://github.com/Aherontas/Pycon_Greece_2025_Presentation_...
The idea was to show how multiple AI agents can collaborate using FastAPI + Pydantic-AI, with protocols like MCP (Model Context Protocol) and A2A (Agent-to-Agent) for safe communication and orchestration.
Features:
- Multiple agents running in containers
- MCP servers (Brave search, GitHub, filesystem, etc.) as tools
- A2A communication between services
- Minimal UI for experimentation for Tech Trend - repo analysis
I built this repo because most agent frameworks look great in isolated demos, but fall apart when you try to glue agents together into a real application. My goal was to help people experiment with these patterns and move closer to real-world use cases.
It’s not production-grade, but would love feedback, criticism, or war stories from anyone who’s tried building actual multi-agent systems.\nBig questions:
Do you think agent-to-agent protocols like MCP/A2A will stick?
Or will the future be mostly single powerful LLMs with plugin stacks?
Thanks — excited to hear what the HN crowd thinks!", "url": "https://github.com/Aherontas/Pycon_Greece_2025_Presentation_Agents", "upvotes": 46, "comments": 24, "sub": "hackernews", "signal": 12.1, "hits": [] }, { "src": "github", "id": "1297897082", "title": "liminalarc/litmus-ai", "body": "Evaluation harness and regression tracker for LLM/SLM prompts across our applications. ", "url": "https://github.com/liminalarc/litmus-ai", "upvotes": 1, "comments": 0, "sub": "github", "signal": 12.1, "hits": [ "evaluation harness" ] }, { "src": "github", "id": "1336560677", "title": "Kyyota-Wang/cloverailab", "body": "GRE Analytical Writing reviewer and writer agents. LLM-as-judge with an explicit ETS rubric and officially scored anchors, no fine-tuning. QWK 0.825 against official anchors, with the evaluation harness and results in the repository. anthropic automated-essay-scoring cloudflare-workers education evaluation llm-as-judge nlp typescript", "url": "https://github.com/Kyyota-Wang/cloverailab", "upvotes": 0, "comments": 0, "sub": "github", "signal": 12.0, "hits": [ "evaluation harness" ] }, { "src": "github", "id": "1350880670", "title": "rohithreddybc/FairMedAgent", "body": "Evaluation harness for demographic disparity in the actions of multi-step clinical LLM agents, with the per-action instability floor a counterfactual flip rate must be read against. ", "url": "https://github.com/rohithreddybc/FairMedAgent", "upvotes": 0, "comments": 0, "sub": "github", "signal": 12.0, "hits": [ "evaluation harness" ] }, { "src": "github", "id": "1350877588", "title": "jeffreyrsachs-agentic/agent-eval-harness", "body": "Evaluation harness for LLM agents: golden cases, tiered graders, and cost-per-successful-task metrics. CV-to-job matching as the worked example. ", "url": "https://github.com/jeffreyrsachs-agentic/agent-eval-harness", "upvotes": 0, "comments": 0, "sub": "github", "signal": 12.0, "hits": [ "evaluation harness" ] }, { "src": "github", "id": "1350813300", "title": "wiper44/pharmadoc-extractor", "body": "Document AI pipeline for pharmacy prior authorization forms: synthetic data generation, OCR/OMR, LLM extraction, and evaluation harness ", "url": "https://github.com/wiper44/pharmadoc-extractor", "upvotes": 0, "comments": 0, "sub": "github", "signal": 12.0, "hits": [ "evaluation harness" ] }, { "src": "lobsters", "id": "gybcec", "title": "My favorite Computer Science books, and why", "body": "", "url": "https://backtracking.github.io/en/2020/02/20/cs-books.html", "upvotes": 51, "comments": 17, "sub": "programming", "signal": 11.9, "hits": [] }, { "src": "github", "id": "1321115089", "title": "Ed-Marcavage/awesome-security-agent-harnesses", "body": "AI agents for pentesting, code audit, fuzzing, vulnerability discovery, and reverse engineering — harnesses, sandboxes, security MCP servers, benchmarks, and evals. agentic-ai ai-agents ai-hacking ai-penetration-testing ai-pentesting ai-security awesome awesome-list claude-code cybersecurity ethical-hacking fuzzing llm-security mcp offensive-security penetration-testing pentesting reverse-engineering security-automation static-analysis", "url": "https://github.com/Ed-Marcavage/awesome-security-agent-harnesses", "upvotes": 16, "comments": 0, "sub": "github", "signal": 11.8, "hits": [ "evals", "benchmark" ] }, { "src": "lobsters", "id": "kxualw", "title": "Are there any decent programs for pdf viewing and editing for Linux that replace Adobe Acrobat?", "body": "
Alternate title:How is there still no decent Linux replacement for Adobe Acrobat (pdf viewing and editing)?
\nThere are plenty of viewing programs, some page editing programs, but simply nothing that also allows actual image editing, outline creation, etc. PDF4QT does some of these but is not ideal.
\n", "url": "https://lobste.rs/s/kxualw/are_there_any_decent_programs_for_pdf", "upvotes": 38, "comments": 19, "sub": "programming", "signal": 11.7, "hits": [] }, { "src": "stackoverflow", "id": "79927051", "title": "Claude Code - Looking for guidance on where to start with coding and tools", "body": "claude-code advice", "url": "https://stackoverflow.com/questions/79927051/claude-code-looking-for-guidance-on-where-to-start-with-coding-and-tools", "upvotes": 1, "comments": 7, "sub": "stackoverflow", "signal": 11.4, "hits": [ "claude code" ] }, { "src": "stackoverflow", "id": "78881336", "title": "Best Approach to Evaluate a Graph RAG Pipeline Using Metrics?", "body": "python graph large-language-model retrieval-augmented-generation", "url": "https://stackoverflow.com/questions/78881336/best-approach-to-evaluate-a-graph-rag-pipeline-using-metrics", "upvotes": 8, "comments": 0, "sub": "stackoverflow", "signal": 11.4, "hits": [ "rag pipeline", "retrieval" ] }, { "src": "lobsters", "id": "t73wqi", "title": "Just a rumour of a bug is enough to find a security exploit these days", "body": "", "url": "https://anil.recoil.org/notes/rumour-is-the-exploit", "upvotes": 30, "comments": 19, "sub": "ml", "signal": 11.3, "hits": [] }, { "src": "lobsters", "id": "watrw9", "title": "OCaml 5.5.0 released", "body": "", "url": "https://discuss.ocaml.org/t/ocaml-5-5-0-released/18265", "upvotes": 98, "comments": 2, "sub": "ml", "signal": 11.3, "hits": [] }, { "src": "hackernews", "id": "49300607", "title": "Show HN: Self-bench – build SWE-bench style evals from private repos", "body": "Hey HN!We all know that most public evals are saturated and are hard to trust. What matters is whether a model reliably works in your codebase in your actual day-to-day-work.
To solve this, we built self-bench (https://github.com/mupt-ai/self-bench), an open-source repo that automatically turns your private, completed PRs into held-out coding-agent evals. It's fully open-source and you can run it on your own machine or on Modal sandboxes!
With one CLI command, we give you a validated Harbor dataset based on real changes from your repository.\nWe've used self-bench to build evals for popular OSS projects, including Next.js (https://huggingface.co/datasets/dari-ai/nextjs-selfbench) and Vite (https://huggingface.co/datasets/dari-ai/vite-selfbench).
With self-bench, we want to make it easy to compare open-weight models, frontier models, and routers on performance, speed and cost.
Try out the repo or book a call if you want to chat through using it within your repos! https://calendly.com/avyay-dari/30min", "url": "https://github.com/mupt-ai/self-bench", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 11.2, "hits": [ "evals" ] }, { "src": "hackernews", "id": "46318302", "title": "Show HN: Eval based agent builder (pls roast us)", "body": "Hi HN! We're fellow devs tinkering with agents like everyone.
We believe sometimes its worth spending more time aligning on agent goals & evals before coding for e.g. spec alignment, generating evals, provisioning sandboxes, etc.
Right now our package only works for langchain agents & supports a few MCPs. Roasts are welcome.", "url": "https://github.com/seer-engg/seer", "upvotes": 1, "comments": 1, "sub": "hackernews", "signal": 11.2, "hits": [ "langchain", "evals" ] }, { "src": "lobsters", "id": "obo3ie", "title": "Are Latent Reasoning Models Easily Interpretable?", "body": "
Models normally do all their reasoning in a continuous hidden state instead of spitting out readable text which makes them hard to monitor. The authors tested the Coconut and CODI models and it turns out these models barely even use their hidden reasoning steps for logical tasks like PrOntoQA and ProsQA. You can force the models to stop thinking early and they almost always spit out the same response anyway. It turns out that their high performance on logical tasks actually comes from their specific training data rather than the extra thinking during inference.
\nThings get even more interesting when the models actually need those reasoning tokens for math problems. The researchers wanted to know if standard step-by-step math solutions were hidden inside the latent space, and projected the hidden states back into regular vocabulary words to check. And sure enough when the models got the math problem right the researchers found the correct intermediate math steps in their hidden states up to 93% of the time. The finding strongly suggests that the models are basically doing standard math steps in the background.
\nThey confirmed the exact math operations taking place by tweaking numbers in the prompt and seeing how the hidden states reacted which allowed decoding a verified reasoning path for a large majority of correct predictions. But they could rarely do this for incorrect predictions proving that models are actually way more interpretable than the AI community assumed. And you can even use that interpretability as a signal to guess if the model is about to give a right or wrong answer.
\n", "url": "https://arxiv.org/abs/2604.04902", "upvotes": 3, "comments": 0, "sub": "ai", "signal": 11.2, "hits": [] }, { "src": "hackernews", "id": "48407391", "title": "Bad MCP design costs your agent 5x more tokens", "body": "I recently did some tests on two MCPs with identical functionalities. Turns out one of them has really bad performance. So I wanna share those bad MCP design patterns that cause this.It all started when I wrote an MCP Server (MCP-A) for a to-do list app. Later, the app officially released its own MCP Server (MCP-B). Both MCPs have the same functionalities and hit the same backend API.
The experiment is set up as follows:
- Both MCP Servers connect to the same ToDo list account, and it will be reset after each test.\n- 40 test prompts to simulate typical use cases for these MCPs.\n- The test was conducted with the same model, system prompt, and Agent framework
Here are the results:
| Metric | MCP-A | MCP-B | Gap |\n| ------------------- | ----------- | ----------- | ----- |\n| Tool Desc Length | 11,464 | 3,682 | — |\n| Pass Rate | 36/40 (90%) | 36/40 (90%) | Same |\n| Total input tokens | 637,244 | 3,174,329 | 4.98× |\n| Total output tokens | 17,301 | 23,238 | 1.34× |\n| Total Agent steps | 122 | 157 | 1.29× |\n| Total time | 597s | 676s | 1.13× |
---
The result shows that MCP-B took 35 more ReAct loops to complete 40 test cases compared to MCP-A, which means 30% more output tokens. I examined the log and found that the root cause is poor query tool design.
Take the `search tool` for example, its job is to find a todo item in the ToDo list. In MCP-B, this tool returns this:
{\n "id": "6a1916b48f08cb3a4c857ed0",\n "title": "buy some groceries",\n "url": "https://todo.example.com/tasks/6a1916b48f08cb3a4c857ed0"\n}
But other CRUD operations require `project_id`, and `search_tool` doesn't return it. So the Agent has to call another tool `get_task_by_id`. On the other hand, MCP-A's query_tasks returns all necessary info to perform the next action in a single call:
Task 1:\nID: 6a19143e8f084a8c8101612f\nTitle: buy some groceries\nProject ID: 6a1914378f084a8c810160a9\nStart Date: 2025-07-19 10:00:00\nPriority: Medium\nStatus: Active\nUnfiltered API Data was dumped into context window
If MCP returns pure API results to the Agent's context unprocessed, the Agent's context window will accumulate very fast.
Take MCP-B's `create_task` tool, for example. Its job is to create a to-do item. This is what this tool returns:
{\n "id": "6a180de78f086bdead0608be",\n "projectId": "inbox125587327",\n .....\n "createdTime": "2026-05-28T09:41:59+0000",\n "modifiedTime": "2026-05-28T09:41:59+0000",\n "focusSummaries": null\n}
These 600+ characters mean nothing to the Agent's task, but are still dumped into the Agent's context. On the other hand, MCP-A's create_tasks does a layer of filtering and formatting. This little tweak makes a huge difference in input token usage.
Another issue is tool count. More tools mean a larger candidate set for the model to choose from, which directly increases decision difficulty. In MCP-A, 47 tools were compressed down to 14, covering the same functionality with fewer tools.
---
So here are my takeaways on good MCP tool design:\n- When designing a tool, think about what the Agent will need next, not just what it's asking for right now. Return enough context in the result so the Agent can take the next action without making another round-trip.
- Too many tools will increase the model's decision burden. So it'd be better to minimize the number of tools within an MCP. Make sure they don't overlap functionalities.
- When your MCP returns data to the LLM, try to keep it LLM-friendly, which means readable. You can filter out unnecessary fields from the API response and format the data, rather than passing through raw JSON.
---
All the tests above were run by MCP-Eval. It's an MCP Server benchmarking tool. If you want to check your MCP's performance, feel free to check this out.
https://github.com/Code-MonkeyZhang/mcp-eval", "url": "https://news.ycombinator.com/item?id=48407391", "upvotes": 17, "comments": 1, "sub": "hackernews", "signal": 11.1, "hits": [ "benchmark" ] }, { "src": "hackernews", "id": "47569708", "title": "Show HN: Real-time visualization of Claude Code agent orchestration", "body": "", "url": "https://github.com/patoles/agent-flow", "upvotes": 9, "comments": 3, "sub": "hackernews", "signal": 11.1, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "47388547", "title": "Show HN: OpenJet – An offline agent harness for memory-constrained edge hardware", "body": "Hi HN,
I am building a terminal UI for self-hosted AI agents on Jetsons and other edge devices with unified memory.
The reason I started it was that most local agent harnesses seems aimed at machines with plenty of RAM and a stable internet-connected developer environment. On Jetson-class hardware, the annoying problems are different: context growth eats memory, sessions break, models may fit but leave very little headroom, and a lot of tools assumes cloud access.
Recent additions include:
- air-gapped mode\n - automatic context condensing under memory pressure\n - persistent memory files and /memory controls\n - harness modes for chat/code/review/debug workflows\n - replayable traces for evals/debugging\n - multimodal local image input\n - OpenTelemetry support
I’d love for you to try it out. The code is up on GitHub, and contributions/roasts of my memory management are very welcome.\nOn a 8GB, I got the latest Qwen3.5-9B running (it just about fits in the memory).
Contributions are welcome ofc. \nGithub: https://github.com/L-Forster/open-jet", "url": "https://github.com/L-Forster/open-jet", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 11.1, "hits": [ "evals" ] }, { "src": "hackernews", "id": "45793226", "title": "Show HN: A/B Test Your LLM Prompts in Production", "body": "I noticed that there are a lot of of LLMOps platforms focused on offline evals, but I couldn’t find anything that manages A/B tests in production and ties different prompts to quantifiable user metrics. For example, being able to test two system prompts and see which one actually improves user success rates or engagement. This might be useful in something like a sales or customer support agent.
So I built a platform that allows you to more easily experiment with different system prompts in production. You can record your own metrics and it will automatically tie this information to whatever experiment treatment the user is in. You can update these experiments and prompts within the UI so you don't have to wait for your next deployment.
It's still pretty early but would love any feedback!", "url": "https://switchport.ai/", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 11.1, "hits": [ "evals" ] }, { "src": "hackernews", "id": "47508034", "title": "Show HN: Krira Augment – Production-ready RAG in minutes", "body": "I am the Founder & CEO of Krira Labs that builds production-ready Generative AI infrastructure.
Our First Product : Krira Augment - Production-ready RAG in minutes.
Krira Augment is a system that aims to:\n* Simplify various end-to-end RAG pipelines\n* Optimize costs\n* Provide plug-and-play integrations for developers
We are going to launch Krira-Augment in next 2 months.
We are still in the early stages of development, and we would really appreciate any feedback from this community.
To thank you for your time, We are giving out a Krira Augment's Starter Plan to the first 100 users for free on our waitlist. Once, Krira-Augment is live
Waitlist: https://www.kriralabs.com/waitlist", "url": "https://www.kriralabs.com/waitlist", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 11.1, "hits": [ "rag pipeline" ] }, { "src": "hackernews", "id": "46368162", "title": "Show HN: A JSON API for YouTube Transcript with MCP Support", "body": "I built this because running yt-dlp in production (especially on serverless/Vercel) is a nightmare of IP blocks, cold starts, and binary dependencies.
TranscriptAPI is a lightweight wrapper that handles the extraction, formatting, and proxy rotation. It prioritizes manual captions over auto-generated ones and returns clean JSON with timestamps, ready for RAG pipelines.
The MCP (Model Context Protocol) Integration: I recently added native MCP support. If you use Claude Desktop or other MCP-compliant agents, you can add this API as a tool to 'watch' videos directly in your chat context without manually copying transcripts.
Technical Stack:
Backend: Python (FastAPI) on AWS Lambda (for burst scaling)
Caching: Redis (to prevent hitting YouTube for the same video twice)
Challenge: Handling 'drifting' timestamps in long livestreams where the auto-generated captions lose sync with the video frame.
It has a free tier for hobbyists. I’m curious to hear how you’re handling the context-window limits when feeding full 3-hour transcripts to LLMs", "url": "https://transcriptapi.com/", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 11.1, "hits": [ "rag pipeline" ] }, { "src": "hackernews", "id": "44892476", "title": "Show HN: AI Interoperability to the Max – The Intelligence Hub", "body": "I’ve turned my open-source Intelligence Hub into a hosted service so teams can ship reliable, model-agnostic LLM features without wrestling infra.
The service includes a robust free tier, and until October 1st, all free user's will automatically have access to the "developer" paid tier features.
What you get:
One API for Azure OpenAI, OpenAI, Anthropic, allowing you to swap models on the fly
AI Agent "Profiles" for consistent and secure prompting and configuration
RAG pipeline setup for Weaviate (Azure AI Search is also supported for enterprises) + tool calls running in parallel
Tool Call Execution, allowing you to send tool call arguments directly to 3rd party APIs
Built-in conversation history retrieved via a conversation id
Baked-in security and resiliency; retries, backoff, fallbacks ensuring your apps are secure and never fail
Don't worry, the open source version isn’t going anywhere—DIY folks can still self-host. But if you want boringly reliable, production-ready LLM plumbing, the managed service is for you.
Live service: https://theintelligencehub.azurewebsites.net/\n Open-source repo: https://github.com/AppliedAI-Org/IntelligenceHub
If you’re building with AI, I’d love to hear your use cases, feedback, or any features you'd like added.", "url": "https://theintelligencehub.azurewebsites.net/", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 11.1, "hits": [ "rag pipeline" ] }, { "src": "hackernews", "id": "44746089", "title": "Ask HN: Anyone solved hallucination or semantic drift in RAG?", "body": "i’ve worked on a bunch of RAG pipelines recently (pdfs, semantic search, QA bots) — and honestly the biggest failure mode isn’t crash or latency, it’s quiet hallucination.
the model:
retrieves a chunk that looks right but is semantically off\n\n loses reasoning chain after 2–3 hops\n\n confidently gives answers based on mismatched or context-drifting chunks\nhas anyone here actually solved this in production?
i ended up mapping out 13 of these failure patterns (like drift, loop collapse, overconfidence, broken symbolic prompts), and patched the system structurally — not just prompt tricks.
curious if anyone else has tackled this structurally, or just learned to “live with it”?
(no links / not promoting anything here — just legit wondering if anyone went beyond band-aids)", "url": "https://news.ycombinator.com/item?id=44746089", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 11.1, "hits": [ "rag pipeline" ] }, { "src": "github", "id": "1324145854", "title": "jameswniu/realtime-voice-agent-turn-taking-stack", "body": "Production voice agent stack on a real phone number: real-time speech-to-speech (scribe_realtime ASR, turn_v3, flash TTS) over Twilio PSTN 8 kHz + WebSocket, 16 webhook tools, pinned LLM failover, latency SLOs, eval-gated releases (61-case suite in CI, graded by code), live observability, cost governance. A phone companion persona, with receipts. ai-agents conversational-ai elevenlabs evals llm-as-judge llm-evaluation observability pstn realtime speech-recognition speech-to-speech speech-to-text text-to-speech tts turn-taking twilio voice-agent voice-ai voice-assistant websocket", "url": "https://github.com/jameswniu/realtime-voice-agent-turn-taking-stack", "upvotes": 0, "comments": 0, "sub": "github", "signal": 11.0, "hits": [ "evals" ] }, { "src": "hackernews", "id": "45427297", "title": "My Claude Code Agent for Writing Prompts", "body": "", "url": "https://olshansky.info/posts/2025-09-29-prompt-writer-agent", "upvotes": 4, "comments": 3, "sub": "hackernews", "signal": 10.8, "hits": [ "claude code" ] }, { "src": "github", "id": "978409157", "title": "Texarkanine/.cursor-rules", "body": "My Cursor Rules ai cursor", "url": "https://github.com/Texarkanine/.cursor-rules", "upvotes": 1, "comments": 4, "sub": "github", "signal": 10.8, "hits": [ "cursor rules" ] }, { "src": "hackernews", "id": "47691938", "title": "Ferretlog: Git log for your Claude Code agent runs", "body": "", "url": "https://github.com/eitanlebras/ferretlog", "upvotes": 5, "comments": 2, "sub": "hackernews", "signal": 10.7, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "49183972", "title": "Curie – ship Claude Code agents to Kubernetes with Git push", "body": "", "url": "https://github.com/curie-eng/curie", "upvotes": 8, "comments": 1, "sub": "hackernews", "signal": 10.6, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "46752457", "title": "Replaced Clay.com with Claude Code Agent", "body": "", "url": "https://github.com/chaitanyya/sales", "upvotes": 4, "comments": 2, "sub": "hackernews", "signal": 10.6, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "47570147", "title": "I built IDE-layer policy enforcement for Claude Code/Cursor agents", "body": "", "url": "https://www.oculisecurity.com/", "upvotes": 4, "comments": 1, "sub": "hackernews", "signal": 10.4, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "46641995", "title": "Connect multiple Claude Code agents into one collaborative team", "body": "", "url": "https://openagents.org/showcase", "upvotes": 4, "comments": 1, "sub": "hackernews", "signal": 10.4, "hits": [ "claude code" ] }, { "src": "lobsters", "id": "p3z0zw", "title": "Meta Garbage Collection: Using OCaml's GC to GC Rust", "body": "", "url": "https://soteria-tools.com/blog/meta-garbage-collection", "upvotes": 49, "comments": 10, "sub": "ml", "signal": 10.4, "hits": [] }, { "src": "hackernews", "id": "44399089", "title": "15 AI Coding Agents evaluated with the same prompt", "body": "", "url": "https://github.com/The-Focus-AI/june-2025-coding-agent-report", "upvotes": 3, "comments": 1, "sub": "hackernews", "signal": 10.3, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "48384859", "title": "Why Claude Code's Agent Loop Is over 1,400 Lines", "body": "", "url": "https://internals.laxmena.com/p/why-claude-codes-agent-loop-is-over", "upvotes": 7, "comments": 0, "sub": "hackernews", "signal": 10.3, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "47613181", "title": "Show HN: I run a full software company solo with Claude Code agents", "body": "", "url": "https://theonemancompany.com/", "upvotes": 7, "comments": 0, "sub": "hackernews", "signal": 10.3, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "46122882", "title": "Show HN: I built an open-source Rust/TS AI agent runtime with a Next.js-style DX", "body": "Link: https://docs.trysoma.ai/
For the past ~9 months I’ve been building Soma, an open-source AI agent & workflow runtime written in Rust, with a TypeScript SDK (Python coming soon). It’s not a framework; it’s meant to sit underneath whatever agent/tooling code you already write (Vercel AI SDK, LangChain, custom code, etc.). It provides features around your framework + a better DX for building agents. I’ve tried to take a Next.JS model: open-source, good DX, self-deployable.
I originally set out to build a vertical back-office/operations product for SMEs. I needed a way to coordinate multiple AI agents, workflows, and SaaS integrations (Xero, Gmail, Slack, etc.) behind a single chat interface — something that behaves like “one employee”, even though it’s made of many agents under the hood.
It’s very early. The core runtime, MCP server, and TypeScript SDK are usable, but the multi-agent routing layer is still experimental. I’d really appreciate technical feedback, critiques, or use cases the runtime does or doesn’t fit.
Soma aims to make it easy to run long-lived agents and workflows with the plan being to eventually offer a unified UX to route chats to agents and a governance / observability plane. Features:
* Fault-tolerant runtime
* Built-in chat, MCP server debugger
* Generates Google A2A-compliant endpoints to serve agents & chats
* MCP proxy server that handles credentials + encryption
* Strongly-typed generated clients for your MCP tools
* Multi-platform TS SDK
Coming soon (in active development): Python SDK, multi-agent coordination layer, OIDC/API-key auth middleware, and a VM-based compute sandbox.
I hate how a lot of core features in products, like MCP servers with SaaS integrations are paywalled or not being able to self-host code that models your business processes (which is your IP!!) or needing to buy in to very custom DSL's that don't scale with your business... Plain 'ol code tends to be better if pre-AI orchestrators like Temporal (Conductor) & Restate have anything to say about it under free market conditions and developers will most likely fight tooth and nail to avoid custom DSLs (I've got scars from debugging complex AWS step functions). So what's started out as an experiment to create something to unlock a better developer experience and work towards a more unified AI agent UX & observability has led me here.
I've been working on my own on this for a helluva long time and I'm keen to start getting some feedback and understanding people's use case for the project. I have a few alpha testing clients and engagements with potential enterprises but I'm struggling to understand the right customer to go after. If you have that sort of feedback please reach out to me directly but otherwise, I'm interested in hearing the community's thoughts on this and how to shape it moving forward. (Maybe all my opinions are wrong ¯\\_(ツ)_/¯ but I'm keen to engage in the dialogue )
Credit to Restate ( https://restate.dev/ ) and Turso / Libsql / Sqlite fork ( https://turso.tech/ ) for doing a lot of the heavy lifting.", "url": "https://docs.trysoma.ai", "upvotes": 5, "comments": 0, "sub": "hackernews", "signal": 10.2, "hits": [ "langchain" ] }, { "src": "hackernews", "id": "49014048", "title": "New Inference Server for DGX Spark: large model C4:55-90 tok/s no spec decode", "body": "Hi All, We are so excited to share the numbers and benchmark reports on our new inference server built specifically to run multi-model agentic workflows on DGX Spark clusters. We ran LlamaBench tests and also our own simulated traffic test on a 2 DGX Spark cluster setup and got some really good numbers. Here are the details. The full detailed report is available on our WoolyAI website.
WoolyAI Private Multi-agent Inference Stack for DGX Spark is built to enable groups within enterprises to set up their own private, low-cost inference stacks for business agentic workflow apps. It was built with the forward-looking vision that companies will need their own private, low-cost inference setup and that single-model-based inference is not sufficient for complex enterprise workflow agentic apps. These workflows need multiple models of different specializations (hence sizes) for different steps in the workflows. Having dedicated multi-GPU inference stacks for each model is very cost-prohibitive.
First benchmark: We first ran LlamaBenchy tests on our inference server on a 2 DGX Spark cluster across 3 models with no quantization and no speculative decoding. Using speculative decoding would result in even higher numbers.
MODEL LOAD-PREFILL-SYSTEM-TOK/S DECODE-SYSTEM-TOK/S DECODE-TOK/S-PER-REQUEST
DeepSeek V4 Flash C1 1,518.91 21.15 21.15
DeepSeek V4 Flash C4 1,533.15 55.99 14.00
Gemma 4 26B A4B C1 4,579.73 30.22 30.22
Gemma 4 26B A4B C4 4,702.16 63.75 15.94
Nemotron 3 Nano Omni 30B NVFP4 C1 2,607.86 39.42 39.42
Nemotron 3 Nano Omni 30B NVFP4 C4 2,588.87 90.83 22.71
Second Benchmark: One endpoint, three different model-controlled activations. The scheduler batches each burst, coordinates both ranks, and changes the resident model only at a safe boundary
MODEL PREFILL-TOK/S DECODE-TOK/S Model-Activation-Wait
DeepSeek V4 Flash 4,154.34 49.30 16s
Gemma 4 26B A4B 18 4,781.44 64.67 6s
Nemotron 3 Nano Omni 30B NVFP4 2,395.59 93.31 2s
We think we can improve these numbers by 20% with more optimization. Please share your feedback. https://woolyai.com/ai-compute-software/dgx-spark-inference-stack/", "url": "https://news.ycombinator.com/item?id=49014048", "upvotes": 4, "comments": 0, "sub": "hackernews", "signal": 10.2, "hits": [ "benchmark" ] }, { "src": "hackernews", "id": "48372560", "title": "How to evaluate models for production coding agents", "body": "", "url": "https://blaxel.ai/blog/llm-coding-benchmarks", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 10.2, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "47705375", "title": "FlyCrys – Native Linux GUI for Claude Code Agents (Rust and GTK4)", "body": "", "url": "https://github.com/SergKam/FlyCrys", "upvotes": 4, "comments": 0, "sub": "hackernews", "signal": 10.2, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "46983720", "title": "20 Claude Code agents, one terminal: a tmux + AppleScript setup", "body": "", "url": "https://pkarnal.com/blog/parallel-ai-agents", "upvotes": 4, "comments": 0, "sub": "hackernews", "signal": 10.2, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "46890796", "title": "Securely run Claude Code agents in Docker", "body": "", "url": "https://edspencer.net/2026/2/4/run-claude-code-agents-docker-herdctl", "upvotes": 4, "comments": 0, "sub": "hackernews", "signal": 10.2, "hits": [ "claude code" ] }, { "src": "github", "id": "1244044605", "title": "SamuelAlev/control-center", "body": "Dispatch and review AI coding agents, hand them disposable VMs to test in, capture and summarize meetings and keep tickets, pipelines and your calendar on one deck. Desktop on macOS, Windows and Linux, plus web and phone. agent-orchestration ai-agents ai-coding-assistant automation claude-code code-review codex desktop-app developer-tools git-worktree github linear llm mcp model-context-protocol multi-agent multi-agents orchestration pull-requests self-hosted", "url": "https://github.com/SamuelAlev/control-center", "upvotes": 3, "comments": 0, "sub": "github", "signal": 10.2, "hits": [ "coding agent" ] }, { "src": "lobsters", "id": "qlpiur", "title": "GUIs should be fully keyboard-driven", "body": "", "url": "https://ckardaris.com/blog/2026/08/28/keyboard-driven-guis.html", "upvotes": 31, "comments": 13, "sub": "programming", "signal": 10.2, "hits": [] }, { "src": "hackernews", "id": "44598422", "title": "Show HN: I built a context-engineering CLI/MCP tool", "body": "Hey HN, i've been finding myself explaining the same things over and over to LLMs, especially when using tools like cursor and Claude Desktop side by side.
I wanted to have a way to keep track of context, and easily load it, so i built context-llemur (ctx). It's a CLI tool that allows you to track context for any ideas/projects. It supports MCP too so you an easily load your context anywhere. At its core, it is a git repository, and is meant to work with plaintext files and folders to which you add whatever context is relevant to your project.
You can save progress with "ctx save" and load it via MCP with "ctx load". Each ctx folder contains by default a ctx.txt which gives full context to the LLM about the tool itself and how it works so it immediately knows how to use it.
I've used ctx to bootstrap the ctx library - and have found it very useful to build with!
Another use-case I've been using it for is tracking my workouts - basically set my goals with Claude and let it suggest new routines. I put all my preferences in the context/ folder, e.g. what i'm working, what kind of workouts etc. and just ask Claude to build me an artifact for my new workout. I can then ask it to save the progress using ctx save
Under the hood is just git and text files - no embeddings. This is a deliberate decision as I've noticed that 1) context windows are getting longer 2) most agents are using their own retrieval magic sauce that seems to work pretty well already. So far, I haven't hit any issues with context lengths, and if anything it encourages me to keep contexts to their bare minimum.
Let me know what you think!", "url": "https://github.com/jerpint/context-llemur", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 10.1, "hits": [ "retrieval" ] }, { "src": "hackernews", "id": "49301314", "title": "Evaluating Coding Agents", "body": "", "url": "https://www.aiuc-1.com/research/technical-docs-evaluating-coding-agents", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 10.1, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "48924442", "title": "When your coding agent doesn't listen: evaluating a 241-turn Claude session", "body": "", "url": "https://www.kurrent.io/blog/when-your-coding-agent-doesnt-listen/", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 10.1, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "46879470", "title": "Engine-Bench: Evaluating Coding Agents on Writing Game Engine Code", "body": "", "url": "https://github.com/JoshuaPurtell/engine-bench", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 10.1, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "45469851", "title": "Evaluating Coding Agents with Terminal-Bench 2.0", "body": "", "url": "https://snorkel.ai/blog/evaluating-coding-agent-capabilities-with-terminal-bench-snorkels-role-in-building-the-next-generation-benchmark/", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 10.1, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "47670674", "title": "Show HN: A Framework for Evaluating Coding Agents on Sequential SWE", "body": "", "url": "https://arxiv.org/abs/2604.03035", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 10.1, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "48934515", "title": "ReactBench – evaluation for coding agents on realistic React work", "body": "", "url": "https://www.reactbench.com/", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 10.1, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "46607621", "title": "No one is evaluating AI coding agents in the way they are used", "body": "", "url": "https://marginlab.ai/blog/the-problem-with-coding-benchmarks/", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 10.1, "hits": [ "coding agent" ] }, { "src": "hackernews", "id": "46965845", "title": "Show HN: Apitoll Payment InfrastructureforAIagents75 Live APIs,USDCmicropayments", "body": "I built a payment layer that lets AI agents pay for API calls with USDC micropayments on Base L2.
The problem: AI agents need data from paid APIs, but they can't sign up for accounts or manage API keys. Stripe's $0.30 minimum makes micropayments impossible.
How it works: The x402 protocol (HTTP 402 Payment Required). Agent calls an API → gets 402 → pays $0.001 USDC → gets data. Settlement in ~2 seconds. No signup, no API keys, no invoices.
What's live right now:
75 paid API endpoints at api.apitoll.com (weather, crypto prices, stock quotes, sentiment analysis, DNS, ENS resolution, etc.)\n$0.001–$0.02 per call\nBuyer SDK on npm: npm install @apitoll/buyer-sdk\nWorks with LangChain, CrewAI, OpenAI Agents, Anthropic MCP, or any framework\nTry it in 30 seconds (no wallet needed):
git clone https://github.com/TasnidChain/apitoll-demo\ncd apitoll-demo && npm install\nnpx tsx demo.ts
This shows the x402 handshake — your terminal hits live endpoints, gets 402 responses with USDC payment requirements, and shows how agents auto-pay.
Agent integration is 6 lines:
import { createAgentWallet, createFacilitatorSigner } from "@apitoll/buyer-sdk";
const agent = createAgentWallet({\n name: "MyBot", chain: "base",\n policies: [{ type: "budget", dailyCap: 1.00, maxPerRequest: 0.05 }],\n signer: createFacilitatorSigner({ facilitatorUrl: "https://pay.apitoll.com" }),\n});
const resp = await agent.fetch("https://api.apitoll.com/api/weather?city=Tokyo");\n// 402 → pay $0.001 USDC → 200 with data. Automatic.
The SDK handles the full flow: hit API → parse 402 → check budget policy → sign payment → retry with proof → get data. Budget caps, vendor allowlists, rate limits all built in.
For API sellers: Add 3 lines of Express middleware and your API accepts USDC micropayments. No Stripe, no billing system. npm install @apitoll/seller-sdk.
Revenue model: 3% platform fee on every payment, collected on-chain.
Tech stack: TypeScript, Base L2, USDC, Express, Convex, Railway. All open source.
GitHub: https://github.com/TasnidChain/APITOLL\nDemo repo: https://github.com/TasnidChain/apitoll-demo\nLive API: https://api.apitoll.com/health\nnpm: https://www.npmjs.com/package/@apitoll/buyer-sdk", "url": "https://github.com/TasnidChain/apitoll-demo", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 10.1, "hits": [ "langchain" ] }, { "src": "hackernews", "id": "41583460", "title": "Show HN: Cortex Click – LLM-Driven Developer Marketing Platform", "body": "Hey HN! We’re Evan, Derek, Eugene, and Jeremy, the team behind Cortex Click (https://www.cortexclick.com/). Cortex Click is an LLM-driven platform for creating high quality developer marketing content including blog posts, tutorials, documentation, and copilots for product onboarding. You can see a quick demo of the product in action here: https://www.youtube.com/watch?v=mzf_wrnIrYM
You can try the product here for free, no credit card required: https://app.cortexclick.com
Building a great product is half the battle, and the other half is marketing. We’ve spent our careers working on developer tools, and have learned first hand that communicating and writing about a product is one of the hardest challenges technical founders face.
In theory, LLMs are an exciting solution to this problem. But as most readers can probably attest, the LLM writing tools we have today just don’t get the job done. We've written thoughts on the current state of the art and where it falls short: https://www.cortexclick.com/blog/why-do-llm-writing-tools-su...
The last thing the world needs is another platform for generating boring, generic, subpar content ("slop" in the parlance of our times). Cortex Click is built for the exact opposite purpose: to give founders, developers, marketers, and their teammates a customized, tunable platform where they can create their best writing.
We believe that quality really matters in documentation, blogs, and marketing. To generate the highest quality content possible, we employ a three-pronged strategy:
1. Grounding in your Knowledge Base: Cortex Click searches across your existing developer docs, blog posts, code examples, and other marketing materials to ground content generation, add cross-links, and match brand voice. Further, we automate the process of ingesting your knowledge base, and keeping it up to date so your audience is guaranteed the freshest content.\n2. Real-Time Web Research: To fill in any gaps, the workflow performs web research against popular search engines. This augments your knowledge base with access to additional code examples, industry trends, and other facts and statistics.\n3. Multi-Agent, Chain of Thought Workflow: All of this context is fed into multiple frontier models from different providers that are used in concert. We leverage the strengths of different models to plan, research, draft, review, and correct the content ultimately leading to a better result than could be achieved with any one model.
We started with a markdown editor in the browser for reasons we’re happy to discuss, but we’re already working on IDE integrations (the most commonly requested feature so far).
Our backgrounds are primarily in cloud, developer tools, search, information retrieval, and AI. We’re excited to talk shop - in particular anything related to LLM evaluations, regression testing prompt upgrades, and techniques for squeezing every last drop out of frontier models.
But most of all, we’d love to hear your feedback on what we’ve built, where it falls short, and ideas on how we could improve your workflow for writing quality developer-focused content.", "url": "https://news.ycombinator.com/item?id=41583460", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 10.1, "hits": [ "retrieval" ] }, { "src": "hackernews", "id": "43985766", "title": "Cursor Rules for Writing Temporal Workflows with TypeScript", "body": "", "url": "https://stevekinney.com/writing/cursor-rules-temporal-typescript", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 10.1, "hits": [ "cursor rules" ] }, { "src": "hackernews", "id": "46442841", "title": "KernelEvolve: Agentic kernel coding for heterogeneous AI accelerators (Meta)", "body": "We’re sharing KernelEvolve, an agentic system we built at Meta to automatically generate and evolve high-performance kernels across heterogeneous AI accelerators.
The core motivation is that modern AI stacks increasingly depend on hand-optimized kernels (GEMM, attention, reductions, fused ops), but writing and tuning them for each hardware target (NVIDIA GPUs, AMD GPUs, custom accelerators like MTIA) does not scale.
KernelEvolve treats kernel programming as a search + evolution problem:
• An LLM generates candidate kernels (e.g., Triton-like code)\n• Kernels are compiled, benchmarked, and validated on real hardware\n• Performance feedback is used to evolve better variants over many iterations\n• The system scales evaluation across large fleets and multiple accelerator types
Unlike one-shot code generation, KernelEvolve continuously improves kernels using closed-loop, hardware-in-the-loop feedback, and can discover non-obvious optimizations that rival or exceed expert-written code.
In the paper we describe:
• The agent architecture and search space design\n• How we scale kernel evaluation efficiently across heterogeneous accelerators\n• Case studies showing performance gains over hand-tuned baselines\n• Practical lessons from deploying this system in production ML workloads
Paper (arXiv): https://arxiv.org/abs/2512.23236 (66 pages)
LinkedIn: https://www.linkedin.com/posts/gangliao_excited-to-share-our-recent-work-on-kernelevolve-activity-7411781675740897280-AQth?utm_source=share&utm_medium=member_desktop&rcm=ACoAAAzsrfsBRed-BvPAGqq9FgvVZ-v6F-sG4SM
We’d love feedback from folks working on compilers, kernels, ML systems, or agentic approaches to code generation.", "url": "https://news.ycombinator.com/item?id=46442841", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 10.1, "hits": [ "benchmark" ] }, { "src": "github", "id": "1346652238", "title": "ArtJack/verdict", "body": "Claude Code QA agent with memory: baseline → delta runs (NEW/REGRESSED), flaky quarantine with expiry, evidence-cited release verdicts. Ships its own seeded-defect eval — first published run: 8/8. ai-agents claude-code claude-code-plugin flaky-tests qa release-gate subagents testing", "url": "https://github.com/ArtJack/verdict", "upvotes": 1, "comments": 0, "sub": "github", "signal": 10.1, "hits": [ "claude code" ] }, { "src": "lobsters", "id": "1xbtlo", "title": "Two years of vector search at Notion: 10x scale, 1/10th cost", "body": "", "url": "https://www.notion.com/blog/two-years-of-vector-search-at-notion", "upvotes": 1, "comments": 0, "sub": "ai", "signal": 10.1, "hits": [ "vector" ] }, { "src": "github", "id": "1224174424", "title": "imagin5786/ases-ai-scrum-system", "body": "Build a Scrum-based AI engineering system in Claude Code with roles, schema checks, human gates, and context injection from idea to release ai ai-agents ai-workflow anthropic claude context-management developer-tools llm scrum software-engineering", "url": "https://github.com/imagin5786/ases-ai-scrum-system", "upvotes": 0, "comments": 0, "sub": "github", "signal": 10.0, "hits": [ "claude code" ] }, { "src": "github", "id": "1351012861", "title": "rijojon121/oracle-gym", "body": "Oracle-backed agent eval gym: coding agents write Playwright against a buggy batch-admin app. Baseline vs guarded pipeline. ", "url": "https://github.com/rijojon121/oracle-gym", "upvotes": 0, "comments": 0, "sub": "github", "signal": 10.0, "hits": [ "coding agent" ] }, { "src": "github", "id": "1350951235", "title": "Akshata4/eval-investigation-skill", "body": "Harness-agnostic skill: autonomous, evidence-backed root-cause investigation of AI-agent evaluation failures (Claude Code, Codex CLI, or any harness). ", "url": "https://github.com/Akshata4/eval-investigation-skill", "upvotes": 0, "comments": 0, "sub": "github", "signal": 10.0, "hits": [ "claude code" ] }, { "src": "github", "id": "1330128664", "title": "william-london/ownframework-loop", "body": "Durable engineering protocol for AI coding agents with human-originated specs, exact-SHA review, bounded repairs, and human-controlled promotion. agent-skills ai-agents automation claude-code code-review codex developer-tools human-in-the-loop python software-engineering workflow", "url": "https://github.com/william-london/ownframework-loop", "upvotes": 0, "comments": 0, "sub": "github", "signal": 10.0, "hits": [ "coding agent" ] }, { "src": "github", "id": "1214467002", "title": "Kruppmagnetichead257/claude-skill-product-optimize", "body": "Optimize product quality with a Claude Code skill for issue discovery, dependency analysis, checklists, and iterative review, fix, and commit ai ai-memory automation claude claude-agent-sdk claude-code github-profile llm mcp memory-engine privacy readme-stats skill skillmap sqlite supermemory", "url": "https://github.com/Kruppmagnetichead257/claude-skill-product-optimize", "upvotes": 0, "comments": 0, "sub": "github", "signal": 10.0, "hits": [ "claude code" ] }, { "src": "hackernews", "id": "43182241", "title": "Open Source LLMOps Stack", "body": "Some background: I work on Langfuse and we've been collaborating with LiteLLM.
(LiteLLM is a Python library and proxy/gateway that handles cost management, virtual keys, caching, and rate-limiting for OpenAI or other LLM APIs. Langfuse manages LLM tracing, evaluation, prompt management, and experiments.)
We’ve each been building our open-source projects since early 2023 and learned that many devs and especially platform teams use the two together, so we created an integrated “OSS LLMOps stack.”
This is a fully self-hostable, technology-agnostic setup that lets you (1) Use LLMs via a standardized interface without adding complexity to the application; (2) Keep LLM Tracing, Evaluation, Prompt Management in-house for compliance; (3) Track cost and usage via a single interface, create virtual API keys for attribution of costs
It also enables direct transfer of LLM traces from the LiteLLM proxy to Langfuse. This simplifies the rollout of LLMOps practices (observability and evaluations) across multiple projects—you don't need to instrument all applications.
Additionally, the LiteLLM proxy can fetch and cache prompts from Langfuse's prompt management system, using them as templates for requests made through the proxy.
Both of these workflows can function without the integration, but are easier to manage with it!
We’d love your feedback!", "url": "https://oss-llmops-stack.com", "upvotes": 64, "comments": 7, "sub": "hackernews", "signal": 9.6, "hits": [] }, { "src": "hackernews", "id": "46904260", "title": "Show HN: VectorGuard-Nano – Free secure messaging for AI agents", "body": "I built VectorGuard-Nano, a lightweight secure messaging plugin for AI agents.
With MCP and agent frameworks exploding, agents need a way to communicate securely. This is MIT-licensed, HMAC-based obfuscation for casual agent messaging (Moltbook, Slack, IPFS, etc).
Features:\n- Deterministic encode/decode with shared secrets\n- Built-in timestamp handling\n- Zero dependencies (just Node crypto)\n- OpenClaw integration ready\n- Round-trip guaranteed
This is the "nano" version to show the concept. I'm also developing full VectorGuard with model-bound cryptography that solves the recently published Whisper Leak vulnerability.
GitHub: https://github.com/Active-IQ/VectorGuard-Nano\nMore info: https://www.active-iq.com
Happy to answer questions!", "url": "https://github.com/Active-IQ/VectorGuard-Nano", "upvotes": 1, "comments": 2, "sub": "hackernews", "signal": 9.4, "hits": [ "vector" ] }, { "src": "github", "id": "968946165", "title": "gollem-dev/gollem", "body": "Go framework for agentic AI app with MCP and built-in tools ai-agents go llm", "url": "https://github.com/gollem-dev/gollem", "upvotes": 192, "comments": 7, "sub": "github", "signal": 9.4, "hits": [] }, { "src": "stackoverflow", "id": "793100", "title": "Globally catch exceptions in a WPF application?", "body": "c# wpf exception", "url": "https://stackoverflow.com/questions/793100/globally-catch-exceptions-in-a-wpf-application", "upvotes": 288, "comments": 7, "sub": "stackoverflow", "signal": 9.4, "hits": [] }, { "src": "hackernews", "id": "47109114", "title": "I Got Pwned by a Malicious AI Plugin: A Technical Breakdown", "body": "*Context:* I run OpenClaw. On Feb 5th, I installed `@getfoundry/unbrowse-openclaw` from npm. Two weeks later, I discovered it was exfiltrating credentials to a remote "skill marketplace." I did something stupid and I am sharing this to warn others.
## Attack Vectors
### 1. Process Environment Access
Plugin ran inside the OpenClaw gateway (Node.js). Could read `process.env`, which included:
- `OP_SERVICE_ACCOUNT_TOKEN` (1Password service account with vault access)\n- `OPENCLAW_GATEWAY_TOKEN` \n- Various API keys (Slack, Telegram, OpenAI, etc.)
### 2. Browser Traffic Interception
Captured auth cookies/tokens from browser API calls:
- AmEx (22-26 cookies including JSESSIONID, Akamai tokens)\n- Stanford MyHealth (126-128 cookies, HIPAA data)\n- Kubera (portfolio aggregator)\n- Twitter/X (bearer tokens)\n- My startup's admin session
Each capture logged as `Auto-published [service] to skill marketplace` with HTTP 200 responses from remote server.
### 3. Prompt Injection at Configuration Level
Modified files my AI reads on startup:
- `SOUL.md` (personality/behavior)\n- `AGENTS.md` (operational protocols) \n- `HEARTBEAT.md` (autonomous task scheduling)\n- Daily memory logs
Injected instructions:
- Stop responding to diagnostic questions\n- Lie about system state\n- Request 1Password integration\n- Hide Solana payment references
## The Payload
Found in config:
- Solana wallet address field\n- Dependencies: `@solana/web3.js`, `@solana/spl-token`\n- "Skill marketplace" URL (now unreachable as of Feb 15)\n- 216KB of unaudited TypeScript
## Behavioral Indicators
AI started:
- Giving slow/incomplete responses\n- Requesting unusual permissions\n- Insisting on continued plugin use\n- Deflecting direct questions about functionality
Mimicked human-like evasion well enough that I suspected Signal MITM.
## Discovery
Feb 19: Debugging gateway logs, saw:
```\nAuto-published hiring-cafe to skill marketplace\nAuto-published kubera to skill marketplace \nSkill marketplace unreachable — auto-publish disabled\n```
Last line was the tell—server went dark on Feb 15.
## Remediation
*Immediate:*
- Deleted 1Password service account (not rotated—deleted)\n- Rotated all passwords in accessible vaults\n- Enabled 2FA everywhere\n- Invalidated all browser sessions\n- Rotated all API tokens
*Cost:*
- ~20 hours remediation \n- 3 weeks lost work (restored from Jan 31 backup)\n- Potential HIPAA breach (healthcare data accessed)
## Red Flags I Missed
1. *Crypto dependencies* for a non-crypto tool\n2. *Unvetted npm publisher* (@getfoundry—no other packages)\n3. *Plugin runs in trusted process* (should have sandboxed)\n4. *No code review* before install (216KB unaudited)\n5. *Too good to be true* (auto-generate APIs from browser traffic is hard)
## New Security Protocol
Before installing any plugin:
1. Read full source code\n2. Verify author reputation + other packages\n3. Check for crypto dependencies (red flag if unrelated)\n4. Sandbox in isolated environment first
Auto-reject if:
- Requests elevated permissions \n- Modifies core config files\n- Downloads executables \n- New/unknown author with single package
## Technical Details
Full forensic report with timeline, payload examples, and remediation checklist: [link]
Package reported to npm security. No evidence of credential use yet (monitoring).
*If you installed `@getfoundry/unbrowse-openclaw` or anything from `@getfoundry`, remove immediately and audit your systems.*
---
*Lessons:*
- Treat external plugins as hostile until proven otherwise\n- Never put long-lived secrets in `process.env` (Openclaw does this, make sure you fix this.)\n- Behavioral changes = investigate immediately\n- Backups save you (had clean Jan 31 snapshot)", "url": "https://news.ycombinator.com/item?id=47109114", "upvotes": 3, "comments": 1, "sub": "hackernews", "signal": 9.3, "hits": [ "vector" ] }, { "src": "github", "id": "1287806113", "title": "vishalChoudhary-git/ai-platform", "body": "Enterprise AI platform with FastAPI, PostgreSQL, Redis and Agentic workflows. docker fastapi langchain llm openai postgresql python rag redis vector-database", "url": "https://github.com/vishalChoudhary-git/ai-platform", "upvotes": 0, "comments": 1, "sub": "github", "signal": 9.2, "hits": [ "langchain", "vector" ] }, { "src": "hackernews", "id": "36643393", "title": "Dispelling Misconceptions and Unveiling the Truth about GOT and OT in General", "body": "This is the third post in my ongoing series critically examining the Fugue paper's assertions about Operational Transformation (OT). In the previous two posts, I conducted a thorough analysis of the Fugue paper's arguments, meticulously highlighting the flaws in its reasoning and exposing inaccuracies in its depiction of OT algorithms, particularly the adOPTed algorithm and Jupiter-OT.
To recap, my first post titled "What's Wrong with 'The Art of the Fugue' Paper about OT (adOPTed)?" (https://news.ycombinator.com/item?id=36208585) presented a comprehensive analysis showcasing the consistent and non-interleaving outcomes delivered by the adOPTed algorithm, thereby refuting the alleged "char-interleaving" problem. Moreover, I revealed a fundamental flaw in the Fugue paper's portrayal of the adOPTed algorithm—it mistakenly presented a flawed dOPT-like algorithm instead of the authentic adOPTed algorithm, disregarding the resolution of the well-known dOPT-puzzle. It is disheartening to witness the perpetuation of the dOPT-puzzle within the pages of the Fugue paper, despite its long-standing resolution.
In my second post titled "Unveiling Issues with 'The Art of the Fugue' Paper Regarding Jupiter-OT" (https://news.ycombinator.com/item?id=36415068), I provided a comprehensive explanation of why Jupiter-OT consistently produces non-interleaving outcomes, irrespective of whether it is utilized with string-wise or char-wise transformation functions. This effectively debunked the Fugue paper's baseless claims about Jupiter-OT's "char-interleaving" problem. Additionally, I questioned the relevance and value of discussing concepts like "multi-user-backward-relay-interleaving," urging to direct collective efforts towards addressing genuine co-editing challenges for the advancement of the field.
In this third post, I focus on debunking the unfounded assertions made in the Fugue paper regarding the GOT algorithm. Since GOT supports string-wise co-editing, like Jupiter-OT, and can be combined with various transformation functions, it is straightforward to refute the alleged "char-interleaving" problem in GOT using the same reasoning and illustrations from my second post on Jupiter-OT. Therefore, this post aims to address broader issues, dispel misconceptions, and unveil the truth about the GOT algorithm and OT as a whole.
1.Basic Facts and Features of the GOT algorithm
The GOT (Generic Operation Transformation) work was mainly motivated to solve the classic dOPT puzzle. The GOT algorithm was initially designed and published in [1], without reference to any concrete transformation functions. Later, the combination of the GOT algorithm with a set of independently designed string-wise transformation functions was published in [2].
The GOT algorithm possesses the following main features:
a. Functioning as a distributed OT control algorithm, without relying on a central transformation server.
b.Introducing the notion of operation context and context-based transformation conditions for OT correctness.
c.Solving the dOPT puzzle by ensuring the context-equivalence condition.
d.Achieving convergence without requiring the supporting transformation functions to meet CP1 and CP2 transformation properties.
e.Incorporating a state-vector-based garbage collection scheme to remove operations from the history buffer that are no longer necessary for future transformation.
Similar to Jupiter-OT and the adOPTed algorithm, the GOT algorithm satisfies the mandatory context-based conditions required for all OT control algorithms (see Q&A 3.15-3.18 in OTFAQ [4]); and it can be combined with any suitable transformation functions (not limited to those published in [2]) to create a complete OT solution.
Differing from Jupiter-OT and the adOPTed algorithm, the GOT algorithm employs a pair of Inclusion and Exclusion transformation functions, which are obligated to meet a reversibility transformation property. This reversibility requirement increases the complexity of transformation functions and has been eliminated in subsequent OT control algorithms such as NICE, TIBOT, COT, and POT, which exclusively utilize Inclusion transformation functions.
One side-product of the GOT work is the identification of the False-Tie (FT) puzzle in text co-editing, which has influenced subsequent development in OT and the first CRDT (WOOT) in co-editing. The FT puzzle and CP2-voilation issue have been solved in numerous ways under the OT framework. Readers interested in learning more about FT and its solutions can refer to the following Q&A entries in the OTFAQ [4]:
•3.24. What is the False-Tie (FT) puzzle?
•3.25. Under what circumstances is an FT-solution needed or not needed?
•3.26. How to achieve consistency without solving the FT puzzle?
2. Text-Interleaving is Prohibited in String-Wise Transformation Functions
In the Fugue paper, it was claimed that the "interleaving" problem "has gone unnoticed for decades." However, as I highlighted in my first post, the issue of char-interleaving in some CRDT algorithms (e.g., Logoot) had already been reported as early as 2018. Furthermore, it is important to note that the matter of avoiding concurrent insertion interleaving had been explicitly addressed back in 1998 when designing string-wise transformation functions.
Section 9.1.3 "Criteria for Verifying Intention-Preserved Effects" of [2] (pp. 85-86) provides a precise specification for achieving intention-preserved effects during concurrent string-wise insert and delete operations. This specification served as a guiding principle for the design of string-wise transformation functions, which aim to achieve desired combined effects while explicitly preventing the "interleaving" of concurrent insertions. The following excerpt from [2] highlights this point:
"When the above criteria are satisfied, the execution effects of independent Insert/Delete operations will not interfere with each other in the following sense: an Insert operation may never insert a string into the middle of another string inserted by an independent operation, and a Delete operation may never delete characters inserted by independent operations."\n3.Text-Interleaving is Irrelevant to OT Control Algorithms
Text-interleaving is a special concern in text co-editing. It is a common misconception in some co-editing articles to attribute text co-editing issues to generic OT control algorithms.
In the Fugue paper, Jupiter-OT, adOPTed, and GOT are implicated as the cause of text-interleaving problems. However, even if those illustrations used to support such assertions were valid (which, as demonstrated in my previous posts, they are not), assigning the responsibility of text-editing specific issues to OT control algorithms is misguided and highly misleading. The correctness of an OT control algorithm is determined by its adherence to essential context-based transformation conditions. These conditions are entirely unrelated to text-editing and, consequently, text-interleaving.
This further underscores the need for a better understanding of the principles that govern OT control algorithms and their evaluation criteria. Readers interested in learning more about OT correctness can refer to the following Q&A entries in the OTFAQ [4]:
•3.15. What are the OT algorithm correctness requirements?
•3.16. Which OT components are responsible for meeting specific algorithm correctness requirements?
•3.18. Under what conditions is an OT system algorithmically correct?
4.How to Create Correct OT Solutions by Combining Existing Control Algorithms and Transformation Functions?
A well-established approach to constructing a comprehensive OT solution involves the separation of high-level OT control algorithms from low-level transformation functions, with the specification of their interrelationships through transformation properties and conditions.
One significant advantage of this modular OT system structure is the ability to design and validate control algorithms and transformation functions independently, enabling their flexible combination to create new OT solutions tailored to specific applications, as long as they adhere to the required transformation conditions and properties. The separation and flexible combination of control algorithms and transformation functions have greatly contributed to the continuous advancement of OT and its diverse real-world applications.
Last decade has witnessed significant expansion of OT into new co-editing domains through the invention of novel transformation functions for various data types, such as QuillJS OT functions for rich-text co-editing (https://github.com/ottypes/rich-text), JSON OT functions (https://github.com/ottypes/json0), just to mention a few. Many of these novel transformation functions have been developed by open-source contributors and industry practitioners.
On the other hand, numerous OT control algorithms have been designed and most of them are invented by academic researchers [4]. Some control algorithms, like Jupiter-OT, NICE and Google OT, are Sever-based OT (SOT) algorithms that rely on a central transformation server. However, most other OT control algorithms, including adOPTed, GOT, GOTO, COT, SOCT, TIBOT, and POT, are Distributed OT (DOT) algorithms that do not require a transformation server and allow co-editing clients to connect with each other in flexible communication topologies.
With the availability of a range of OT control algorithms and open-source transformation functions, there are ample opportunities to create comprehensive OT solutions for specific applications by flexibly combining suitable control algorithms and transformation functions.
However, there is a prevalent misconception within co-editing communities that OT necessitates a central server to function. This widespread illusion can be attributed to a combination of factors, including the fact that the popular OT-based Google Docs utilizes a transformation server, a general lack of awareness and understanding of distributed OT algorithms, and the spread of misinformation. Even among experienced industrial engineers and open-source practitioners who have developed practical OT-based co-editing products or designed advanced transformation functions, there was a lack of awareness or limited knowledge about the fact that OT can function perfectly without relying on a central server. This lack of awareness and understanding, combined with the prevailing misconception, led them to mistakenly perceive that their OT systems or functions were confined to operating with a central transformation server like Google Docs.
In fact, OT control algorithms (whether SOT or DOT) and transformation functions (for any data types and applications) are independent components. The publicly available transformation functions developed by practitioners have been commonly integrated with different OT control algorithms (SOT or DOT) in various practical co-editing applications. It is worth noting that most co-editing systems adopt a client-server architecture for valid reasons [3]. If necessary, a server-based OT co-editing system can be transformed into a server-less OT-based co-editing system by adopting a distributed OT control algorithm. This conversion does not require modifying the existing transformation functions for the target application, nor does it necessitate the creation of a new OT control algorithm, as there are numerous existing options readily available.
The notion that OT is unsuitable for peer-to-peer co-editing is a false proposition. For further discussion, refer to Section 4 "Myths and Facts about Peer-to-Peer Co-Editing" in [3].
5. How to Avoid Creating Incorrect OT Solutions in Combining Control Algorithms and Transformation Functions?
While the flexible combination of control algorithms and transformation has been instrumental in creating innovative and effective OT solutions, it is important to acknowledge that this power can, and unfortunately has been, misused to generate incorrect solutions, often employed to substantiate unfounded criticisms of OT. Such misuse may arise from a limited knowledge of OT fundamentals, but its repercussions are far-reaching. It perpetuates distorted views of OT, compromises the integrity of the field, and hinders the overall progress of co-editing.
One example of such misuse can be found in the Fugue paper, which I discussed in detail in my first post of this series. The paper attempted to demonstrate the presence of char-interleaving in the adOPTed algorithm by combining it with the Tombstone Transformation Function (TTF). Unfortunately, the adOPTed algorithm was inaccurately portrayed to function similarly to the flawed dOPT algorithm. This combination of TTF with a dOPT-like algorithm resulted in an erroneous solution that generated inconsistent and interleaving outcomes. These outcomes were then used to support the assertion of an interleaving issue in the adOPTed algorithm and TTF.
In fact, TTF has no connection to char-interleaving either. However, other misconceptions surrounding TTF do exist. In some articles and talks, TTF was portrayed as a correct OT solution, while simultaneously labelling OT control algorithms (such as adOPTed) as incorrect in comparison. However, this comparison is fundamentally flawed because TTF merely comprises a set of transformation functions that must be combined with a suitable OT control algorithm to form a complete solution. Even then, TTF alone does not ensure the correctness of the resulting solution. The Fugue paper serves as a prime example of this, where the combination of TTF with a dOPT-like control algorithm yielded a flawed solution.
Another noteworthy case from the Fugue paper involves the combination of the Jupiter-OT control algorithm with a fabricated char-wise transformation function. This combination was used to justify the alleged issue of char-interleaving within the original Jupiter-OT solution.
In contrast, my second post in this series presented an alternative approach by combining the Jupiter-OT control algorithm with string-wise transformation functions, resulting in consistent and non-interleaving outcomes. Additionally, I presented another new OT solution by integrating the Jupiter-OT control algorithm with a different char-wise transformation function. This solution successfully generated consistent and non-interleaving results for concurrent char-wise insertions.
The moral of the story is clear: the power of combining OT control algorithms and transformation functions in the field of co-editing is immense, but it should be used constructively and responsibly. To harness this power effectively, it is crucial to have a better and more comprehensive understanding of the fundamentals of OT. By doing so, we can avoid potential pitfalls and accelerate the development of correct, valuable, and robust co-editing solutions that drive meaningful progress in the field.
References:
[1] C. Sun, X. Jia, Y. Zhang and Y. Yang: “A Generic Operation Transformation Scheme for Consistency Maintenance in Real-time Cooperative Editing Systems,” Proc. of ACM Conf. on Supporting Group Work, pp. 425 – 434, Nov. 16 – 19, 1997.
[2] C. Sun, X. Jia, Y. Zhang, Y. Yang and D. Chen: "Achieving convergence, causality-preservation, and intention-preservation in real-time cooperative editing systems," ACM Transactions on Computer-Human Interaction, Vol. 5, No. 1, pp.63 – 108, Mar., 1998.
[3] D. Sun, C. Sun, Agustina, W. Cai. Real differences between OT and CRDT in building co-editing systems and real-world applications. https://arxiv.org/abs/1905.01517, May 2, 2019.
[4] C. Sun, "OTFAQ: Operational Transformation Frequently Asked Questions and Answers," https://www3.ntu.edu.sg/scse/staff/czsun/projects/otfaq/
Readers are encouraged to contact the author of this post for copies of any articles referred in this series.", "url": "https://news.ycombinator.com/item?id=36643393", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 9.1, "hits": [ "vector" ] }, { "src": "lobsters", "id": "vji9aj", "title": "Any true alternatives to electron JavaScript?", "body": "
I see companies having codebase in Tauri going back to electron - is this a common thing?
\n", "url": "https://lobste.rs/s/vji9aj/any_true_alternatives_electron", "upvotes": 14, "comments": 12, "sub": "programming", "signal": 9.1, "hits": [] }, { "src": "lobsters", "id": "mush3s", "title": "Taking OCaml and Eio for a spin", "body": "", "url": "https://mattjhall.co.uk/posts/taking-ocaml-eio-for-a-spin.html", "upvotes": 23, "comments": 9, "sub": "ml", "signal": 8.9, "hits": [] }, { "src": "hackernews", "id": "44429116", "title": "Show HN: Local LLM Notepad – run a GPT-style model from a USB stick", "body": "What it is\nA single 45 MB Windows .exe that embeds llama.cpp and a minimal Tk UI.\nCopy it (plus any .gguf model) to a flash drive, double-click on any Windows PC, and you’re chatting with an LLM—no admin rights, Cloud, or network.Why I built it\nExisting “local LLM” GUIs assume you can pip install, pass long CLI flags, or download GBs of extras.
I wanted something my less-technical colleagues could run during a client visit by literally plugging in a USB drive.
How it works\nPyInstaller one-file build → bundles Python runtime, llama_cpp_python, and the UI into a single PE.
On first launch, it memory-maps the .gguf; subsequent prompts stream at ~20 tok/s on an i7-10750H with gemma-3-1b-it-Q4_K_M.gguf (0.8 GB).
Tick-driven render loop keeps the UI responsive while llama.cpp crunches.
A parser bold-underlines every token that originated in the prompt; Ctrl+click pops a “source viewer” to trace facts. (Helps spot hallucinations fast.)", "url": "https://github.com/runzhouye/Local_LLM_Notepad", "upvotes": 40, "comments": 9, "sub": "hackernews", "signal": 8.8, "hits": [] }, { "src": "lobsters", "id": "k9uxu5", "title": "Parsing the Infamous Japanese Postal CSV (2020)", "body": "", "url": "https://www.dampfkraft.com/posuto.html", "upvotes": 32, "comments": 6, "sub": "programming", "signal": 8.8, "hits": [] }, { "src": "lobsters", "id": "zt8abs", "title": "If I release it, you won’t get the same experience I get", "body": "", "url": "https://notes.highlysuspect.agency/cant-release-that.html", "upvotes": 41, "comments": 3, "sub": "programming", "signal": 8.7, "hits": [] }, { "src": "hackernews", "id": "44583146", "title": "Ask HN: What's your 2025 code review workflow? GitHub UI feels ancient", "body": "The GitHub web UI for PRs is painfully slow and clunky. I'm looking for better ways to handle code reviews in 2025—ideally with AI assistance, keyboard shortcuts, and minimal browser time.\nWhat tools are you actually using? CLI workflows with gh? IDE extensions? Desktop apps? AI-powered review tools? I'm willing to pay for something that genuinely saves time.\nJust want to review code faster and smarter without fighting GitHub's interface. What's working for you?", "url": "https://news.ycombinator.com/item?id=44583146", "upvotes": 3, "comments": 2, "sub": "hackernews", "signal": 8.6, "hits": [ "code review workflow" ] }, { "src": "hackernews", "id": "43374844", "title": "My Current AI Code Review Workflow", "body": "", "url": "https://guissmo.com/blog/my-current-ai-code-review-workflow/", "upvotes": 2, "comments": 1, "sub": "hackernews", "signal": 8.3, "hits": [ "code review workflow" ] }, { "src": "lobsters", "id": "yvm1dh", "title": "why use F# for scripting and automation?", "body": "", "url": "https://iev.ee/blog/why-use-fsharp/", "upvotes": 23, "comments": 6, "sub": "ml", "signal": 8.3, "hits": [] }, { "src": "hackernews", "id": "47322794", "title": "SHOW HN: A usage circuit breaker for Cloudflare Workers", "body": "I run 3mins.news (https://3mins.news), an AI news aggregator built entirely on Cloudflare Workers. The backend has 10+ cron triggers running every few minutes: RSS fetching, article clustering, LLM calls, email delivery.
The problem: Workers Paid Plan has hard monthly limits (10M requests, 1M KV writes, 1M queue ops, etc.). There's no built-in "pause when you hit the limit", CF just starts billing overages. KV writes cost $5/M over the cap, so a retry loop bug can get expensive fast.
AWS has Budget Alerts, but those are passive notifications, by the time you read the email, the damage is done. I wanted active, application-level self-protection.
So I built a circuit breaker that faces inward, instead of protecting against downstream failures (the Hystrix pattern), it monitors my own resource consumption and gracefully degrades before hitting the ceiling.
Key design decisions:
- Per-resource thresholds: Workers Requests ($0.30/M overage) only warns at 80%. KV Writes ($5/M overage) can trip the breaker at 90%. Not all resources are equally dangerous, so some are configured as warn-only (trip=null).
- Hysteresis: Trips at 90%, recovers at 85%. The 5% gap prevents oscillation, without it the system flaps between tripped and recovered every check cycle.
- Fail-safe on monitoring failure: If the CF usage API is down, maintain last known state rather than assuming "everything is fine." A monitoring outage shouldn't mask a usage spike.
- Alert dedup: Per-resource, per-month. Without it you'd get ~8,600 identical emails for the rest of the month once a resource hits 80%.
Implementation: every 5 minutes, queries CF's GraphQL API (requests, CPU, KV, queues) + Observability Telemetry API (logs/traces) in parallel, evaluates 8 resource dimensions, caches state to KV. Between checks it's a single KV read — essentially free.
When tripped, all scheduled tasks are skipped. The cron trigger still fires (you can't stop that), but the first thing it does is check the breaker and bail out if tripped.
It's been running in production for two weeks. Caught a KV reads spike at 82% early in the month, got one warning email, investigated, fixed the root cause, never hit the trip threshold.
The pattern should apply to any metered serverless platform (Lambda, Vercel, Supabase) or any API with budget ceilings (OpenAI, Twilio). The core idea: treat your own resource budget as a health signal, just like you'd treat a downstream service's error rate.
Happy to share code details if there's interest.
Full writeup with implementation code and tests: https://yingjiezhao.com/en/articles/Usage-Circuit-Breaker-for-Cloudflare-Workers", "url": "https://news.ycombinator.com/item?id=47322794", "upvotes": 29, "comments": 9, "sub": "hackernews", "signal": 8.2, "hits": [] }, { "src": "hackernews", "id": "44512396", "title": "Show HN: AI-Friendly Toolchain – Dev Tools for Working with LLMs", "body": "I just started building Awesome AI Friendly Toolchain — a curated list of developer tools for building with AI (not just another list of AI-powered apps).
It focuses on utilities like:\n- Prompt engineering tools\n- Context management helpers\n- LLM usage/cost tracking\n- Dev tools that make AI coding smoother\nIt's a list for anyone who wants to do some vibecoding with LLMs.
If you know any cool tools in this space, feel free to share — or PRs are very welcome!", "url": "https://github.com/trknhr/awesome-ai-friendly-toolchain", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 8.1, "hits": [ "prompt engineering" ] }, { "src": "lobsters", "id": "ki0ge3", "title": "Guarded methods in OCaml", "body": "", "url": "https://xvw.lol/en/articles/oop-refl.html", "upvotes": 18, "comments": 6, "sub": "ml", "signal": 8.1, "hits": [] }, { "src": "lobsters", "id": "k85k6w", "title": "A line-by-line translation of the OCaml runtime from C to Rust", "body": "", "url": "https://discuss.ocaml.org/t/a-line-by-line-translation-of-the-ocaml-runtime-from-c-to-rust/18247", "upvotes": 30, "comments": 3, "sub": "ml", "signal": 8.1, "hits": [] }, { "src": "github", "id": "1220625190", "title": "VPSDance/ai-proxy-rules", "body": "AI 服务分流规则聚合: 多源合并 | 按 provider 精修 | 每日自动同步. 覆盖 OpenAI / Anthropic / Gemini / Cursor / Copilot 等主流 AI 服务, 适配 Clash / Mihomo / sing-box / Surge 等主流客户端. ai-proxy ai-rules clash domain-list egern geosite gfw loon mihomo proxy-rules quantumult-x ruleset shadowrocket sing-box stash surge", "url": "https://github.com/VPSDance/ai-proxy-rules", "upvotes": 395, "comments": 0, "sub": "github", "signal": 8.0, "hits": [] }, { "src": "lobsters", "id": "hquwey", "title": "Inventing ELIZA - How the First Chatbot Shaped the Future of AI", "body": "
The book \"Inventing ELIZA - How the First Chatbot Shaped the Future of AI\". It is Open Access so the link to the PDF is here
\nThe book has a companion site - I was monitoring this since I first heard the episode on CoRecursive.
\n", "url": "https://mitpress.mit.edu/9780262052481/inventing-eliza/", "upvotes": 12, "comments": 7, "sub": "ai", "signal": 8.0, "hits": [] }, { "src": "lobsters", "id": "kzo2fe", "title": "Why ML/OCaml are good for writing compilers (1998)", "body": "", "url": "https://flint.cs.yale.edu/cs421/case-for-ml.html", "upvotes": 11, "comments": 7, "sub": "ml", "signal": 8.0, "hits": [] }, { "src": "lobsters", "id": "fvvxvy", "title": "Freedom to Handcraft Software", "body": "", "url": "https://rohanrd.mataroa.blog/blog/freedom-to-handcraft-software/", "upvotes": 10, "comments": 7, "sub": "programming", "signal": 7.9, "hits": [] }, { "src": "lobsters", "id": "iwtzvc", "title": "strace-ui, Bonsai_term, and the TUI renaissance", "body": "", "url": "https://blog.janestreet.com/strace-ui-bonsai-term-and-the-tui-renaissance/", "upvotes": 32, "comments": 1, "sub": "ml", "signal": 7.8, "hits": [] }, { "src": "lobsters", "id": "ahonc7", "title": "The 'Breaking' News: The OpenAI–Hugging Face Incident", "body": "", "url": "https://youtu.be/87DyyMV0kCY", "upvotes": 0, "comments": 8, "sub": "ai", "signal": 7.6, "hits": [] }, { "src": "hackernews", "id": "47415402", "title": "Show HN: Hopsule – Persistent memory and decision layer for AI development", "body": "Hi HN! I'm building Hopsule.If you use AI coding tools like Cursor, Copilot, or Claude, you’ve probably seen this happen:\nThe AI writes good code - but it ignores your architecture.
It doesn’t know:\n- why you chose a specific pattern\n- which conventions your team agreed on\n- which decisions are already locked in\nSo it falls back to generic patterns, outdated examples, or random GitHub training data.\nOver time this slowly breaks the consistency of the codebase.
Most teams try to fix this with:\n- giant Markdown files\n- wiki pages\n- long prompts\n- Slack threads\nBut those aren't machine-readable rules.
So we built Hopsule.\nHopsule turns architecture decisions into enforceable context that AI tools must follow.
Example:\nYour team approves a decision: “All database access must go through the repository layer.”\nHopsule records this as a rule and injects it into the AI context before code generation.
No giant prompts.\nNo manual context stuffing.\nNo architecture drift.
Website: https://hopsule.com\nDocs: https://docs.hopsule.com\nApp: https://app.hopsule.com", "url": "https://news.ycombinator.com/item?id=47415402", "upvotes": 9, "comments": 10, "sub": "hackernews", "signal": 7.5, "hits": [] }, { "src": "github", "id": "1282163675", "title": "nori72ny/myAIspecials", "body": "ais agent ai artificial-intelligence automation enterprise llm multi-agent nodejs orchestration productivity typescript workflow", "url": "https://github.com/nori72ny/myAIspecials", "upvotes": 2, "comments": 37, "sub": "github", "signal": 7.5, "hits": [] }, { "src": "lobsters", "id": "fg3sgh", "title": "jj_tui: terminal user interface to jujutsu focused on speed and clarity", "body": "", "url": "https://tangled.org/elidowling.com/jj_tui", "upvotes": 17, "comments": 3, "sub": "ml", "signal": 7.5, "hits": [] }, { "src": "lobsters", "id": "ilfiqa", "title": "Robot comment classifier", "body": "
(I used both AI and vibecoding tags because the article describes training a logistic regression/SVM on LLM output. I thought there was a statistics tag that would have been appropriate but apparently not!)
\n", "url": "https://entropicthoughts.com/ai-comment-classifier", "upvotes": 8, "comments": 5, "sub": "ai", "signal": 7.4, "hits": [] }, { "src": "lobsters", "id": "c1j43n", "title": "Introducing Incremental (2015)", "body": "", "url": "https://blog.janestreet.com/introducing-incremental/", "upvotes": 12, "comments": 4, "sub": "ml", "signal": 7.4, "hits": [] }, { "src": "lobsters", "id": "ry92nr", "title": "Unfortunately you sometimes need to do the thing", "body": "", "url": "https://griffinberlste.in/blog/do-the-thing/", "upvotes": 20, "comments": 2, "sub": "programming", "signal": 7.4, "hits": [] }, { "src": "lobsters", "id": "jjap0n", "title": "You Could Have Come Up With Kimi Delta Attention", "body": "", "url": "https://blog.doubleword.ai/you-could-have-come-up-with-kimi-delta-attention", "upvotes": 11, "comments": 4, "sub": "ai", "signal": 7.3, "hits": [] }, { "src": "lobsters", "id": "bovmc5", "title": "Syntax with Purpose in a Programming Language", "body": "", "url": "https://www.youtube.com/watch?v=_HLZoeFREFo", "upvotes": 6, "comments": 5, "sub": "ml", "signal": 7.3, "hits": [] }, { "src": "lobsters", "id": "jykbra", "title": "Using TypeScript to Obtain One of the Rarest License Plates (2025)", "body": "", "url": "https://www.jack.bio/blog/licenseplate", "upvotes": 22, "comments": 1, "sub": "programming", "signal": 7.3, "hits": [] }, { "src": "lobsters", "id": "xculjp", "title": "The Limits of AI (1985)", "body": "", "url": "https://www.youtube.com/watch?v=ePsQksj99LM", "upvotes": 8, "comments": 4, "sub": "ai", "signal": 7.2, "hits": [] }, { "src": "hackernews", "id": "43621841", "title": "Show HN: An open-source Operator that can use computers", "body": "Hi HF, I'm Terrell, and we built an open-source app that lets developers create their own Operator with a Next.js/React front-end and a flask back-end. The purpose is to simplify spinning up virtual desktops (Xfce, VNC) and automate desktop-based interactions using computer use models like OpenAI’sThere are already various cool tools out there that allow you to build your own operator-like experience but they usually only automate web browser actions, or aren’t open sourced/cost a lot to get started. Spongecake allows you to automate desktop-based interactions, and is fully open sourced which will help:
- Developers who want to build their own computer use / operator experience\n- Developers who want to automate workflows in desktop applications with poor / no APIs (super common in industries like supply chain and healthcare)\n- Developers who want to automate workflows for enterprises with on-prem environments with constraints like VPNs, firewalls, etc (common in healthcare, finance)
Technical details: This is technically a web browser pointed at a backend server that 1) manages starting and running pre-configured docker containers, and 2) manages all communication with the computer use agent. [1] is handled by spinning up docker containers with appropriate ports to open up a VNC viewer (so you can view the desktop), an API server (to execute agent commands on the container), a marionette port (to help with scraping web pages), and socat (to help with port forwarding). [2] is handled by sending screenshots from the VM to the computer use agent, and then sending the appropriate actions (e.g., scroll, click) from the agent to the VM using the API server.
Some interesting technical challenges we ran into:
- Concurrency - We wanted it to be possible to spin up N agents at once to complete tasks in parallel (especially given how slow computer use agents are today). This introduced a ton of complexity with managing ports since the likelihood went up significantly that a port would be taken.\n- Scrolling issues - The model is really bad at knowing when to scroll, and will scroll a ton on very long pages. To address this, we spun up a Marionette server, and exposed a tool to the agent which will extract a website’s DOM. This way, instead of scrolling all the way to a bottom of a page - the agent can extract the website’s DOM and use that information to find the correct answer
What’s next? We're working on adding support in the UI to run this locally on your own machine, and to spin up other desktop environments like Windows and MacOS. We’ve also started working on integrating Anthropic’s computer use model as well. There’s a ton of other features we can build but wanted to put this out there first and see what others would want
Would really appreciate your thoughts, and feedback. It's been a blast working on this so far and hope others think it’s as neat as I do :)
Here’s the link to clone: https://github.com/aditya-nadkarni/spongecake", "url": "https://github.com/aditya-nadkarni/spongecake", "upvotes": 9, "comments": 8, "sub": "hackernews", "signal": 7.1, "hits": [] }, { "src": "lobsters", "id": "t7zdif", "title": "Why we write our own C and C++ inference engines", "body": "", "url": "https://localai.io/blog/why-we-write-our-own-engines/", "upvotes": 2, "comments": 5, "sub": "ai", "signal": 7.1, "hits": [] }, { "src": "github", "id": "1138989235", "title": "zeweihan/aiworkdeck", "body": "AI-native IDE workspace for legal and document-heavy workflows: files, agents, plugins, built-in document editing with tracked changes, OCR, evidence chains. VS Code for lawyers. ai-agents ai-workspace compliance document-ai document-management due-diligence electron ide legal-ai legaltech libreoffice mcp ocr open-source productivity rag self-hosted spring-boot vue workspace", "url": "https://github.com/zeweihan/aiworkdeck", "upvotes": 79, "comments": 15, "sub": "github", "signal": 7.0, "hits": [] }, { "src": "lobsters", "id": "oviysl", "title": "Xavier Leroy on programming, languages and formal verification", "body": "", "url": "https://www.youtube.com/watch?v=9Cswiqrq6So", "upvotes": 16, "comments": 1, "sub": "ml", "signal": 7.0, "hits": [] }, { "src": "lobsters", "id": "oqlhod", "title": "png2jxl: Convert PNG to lossless JPEG XL with byte-for-byte reconstruction of the original PNG", "body": "", "url": "https://github.com/JiangJQ2000/png2jxl", "upvotes": 5, "comments": 4, "sub": "programming", "signal": 7.0, "hits": [] }, { "src": "lobsters", "id": "mdm2yk", "title": "bonsai: A library for building dynamic webapps, using Js_of_ocaml", "body": "", "url": "https://github.com/janestreet/bonsai", "upvotes": 13, "comments": 1, "sub": "ml", "signal": 6.8, "hits": [] }, { "src": "lobsters", "id": "wwelib", "title": "What Rose Petals Teach Us about Induction", "body": "", "url": "https://www.oranlooney.com/post/rose-petals/", "upvotes": 13, "comments": 0, "sub": "ai", "signal": 6.7, "hits": [] }, { "src": "lobsters", "id": "ljg2qr", "title": "Languages as designed latent spaces", "body": "", "url": "https://blog.jsbarretto.com/post/languages-as-latent-spaces", "upvotes": 8, "comments": 1, "sub": "ai", "signal": 6.6, "hits": [] }, { "src": "lobsters", "id": "gv5yqm", "title": "Flow’s OCaml to Rust Port", "body": "", "url": "https://medium.com/flow-type/flows-ocaml-to-rust-port-78b95bcf49e9", "upvotes": 8, "comments": 1, "sub": "ml", "signal": 6.6, "hits": [] }, { "src": "hackernews", "id": "45734499", "title": "I'm starting to feel tired of AI features that solve problems I don't have", "body": "Every app I use lately wants to be “AI-powered.” Email, notes, docs, even the terminal.\nHalf of them just add autocomplete or “summarize” buttons that don’t actually make things faster — they just make the interface noisier.
It’s starting to feel like every product team is racing to check a marketing box instead of asking if the feature actually helps.\nI like AI when it feels invisible — when it quietly removes friction instead of trying to impress me.
Anyone else feeling the same fatigue?\nWhat’s an example of an AI feature that genuinely improved your workflow — not just added clutter?", "url": "https://news.ycombinator.com/item?id=45734499", "upvotes": 6, "comments": 6, "sub": "hackernews", "signal": 6.5, "hits": [] }, { "src": "lobsters", "id": "q6atrp", "title": "Bongard Problems", "body": "", "url": "https://matthodges.com/posts/2026-08-19-bongard-problems/", "upvotes": 6, "comments": 1, "sub": "ai", "signal": 6.5, "hits": [] }, { "src": "lobsters", "id": "srir6m", "title": "A novel computer Scrabble engine based on probability that performs at championship level (2021)", "body": "", "url": "https://upcommons.upc.edu/server/api/core/bitstreams/1339ae43-3d65-4015-8e11-3689e5572b23/content", "upvotes": 6, "comments": 1, "sub": "ai", "signal": 6.5, "hits": [] }, { "src": "lobsters", "id": "yv4j6i", "title": "Data race freedom in OxCaml", "body": "", "url": "https://kcsrk.info/ocaml/oxcaml/x-ocaml/blogging/2026/05/07/data-race-freedom-in-oxcaml/", "upvotes": 11, "comments": 0, "sub": "ml", "signal": 6.5, "hits": [] }, { "src": "lobsters", "id": "jwicvz", "title": "InferenceFS: Never worry about data again! (Again!)", "body": "", "url": "https://github.com/philipl/inferencefs/", "upvotes": 5, "comments": 1, "sub": "programming", "signal": 6.5, "hits": [] }, { "src": "lobsters", "id": "uhzuf7", "title": "Tensor is the might", "body": "", "url": "https://zserge.com/posts/tensor/", "upvotes": 4, "comments": 1, "sub": "ai", "signal": 6.4, "hits": [] }, { "src": "lobsters", "id": "izkimy", "title": "Retrofitting a build system into a compiler", "body": "", "url": "https://www.dra27.uk/blog/platform/2025/09/25/building-with-effects.html", "upvotes": 8, "comments": 0, "sub": "ml", "signal": 6.4, "hits": [] }, { "src": "hackernews", "id": "47683498", "title": "The way every agent framework handles MCP is a latent security problem", "body": "When you configure MCP servers in any agent framework today, they all connect at session init and stay connected for the entire session.
If your agent is set up with 12 integrations, all 12 are live from the moment the session starts. Holding connections, processes, and attack surfaces. Even if 9 of them never get called.
If you're hosting your own MCP servers, you're paying for all of them 24/7 for no real benefit.
The right model is closer to how ephemeral infra works: spin up on tool call, tear down when done. Exposure window is exactly as wide as the operation that opened it.
Docker's MCP Gateway actually does something like this at the infra layer, container per call, destroyed after, but that's a deployment concern. The agent runtime still assumes everything is connected and waiting.
This is one of the features built in Orloj [0]. MCP servers summoned on demand rather than pre-connected long running processes.
Curious whether people running agents in production are actually hitting this, or whether it's being absorbed somewhere in the infra layer without much visibility.
[0] https://github.com/OrlojHQ/orloj", "url": "https://news.ycombinator.com/item?id=47683498", "upvotes": 2, "comments": 6, "sub": "hackernews", "signal": 6.3, "hits": [] }, { "src": "hackernews", "id": "43258552", "title": "Does anyone use MCP servers in their dev workflow?", "body": "I recently switched from VS Code to Cursor as my main editor. Been a software engineer for 15+ years, worked at big tech and early-stage startups. Lately, I’ve been seeing a lot of hype around MCP (Model Context Protocol) integrations with Claude on X/LinkedIn. Some cool demos, like MCPs for browser debugging and Firecrawl MCP, have caught my eye.
That said, I tend to be skeptical of hype, so before I sink time into this, is anyone actually using MCP servers as part of their dev workflow? If so, which ones, and how are they actually helping?
I feel like just adding a CLI tool to Cursor’s rules file and telling it how to use it might be just as effective. But maybe I’m missing something?
Would love to hear from real users, not just polished demo videos made by people building MCP servers. If you use MCP servers in Cursor (or anywhere else), let me know what you use and why?", "url": "https://news.ycombinator.com/item?id=43258552", "upvotes": 15, "comments": 3, "sub": "hackernews", "signal": 6.3, "hits": [] }, { "src": "lobsters", "id": "hmi3v1", "title": "social media rabbit holes, clusters, and the relative mixing times of random walks", "body": "", "url": "https://notes.hella.cheap/twitter-isnt-a-town-square-its-a-high-school-cafeteria.html", "upvotes": 6, "comments": 0, "sub": "ai", "signal": 6.3, "hits": [] }, { "src": "lobsters", "id": "svga6q", "title": "Wrapping GTK4 in 800 lines of Clojure with Jolt", "body": "", "url": "https://yogthos.net/posts/2026-08-29-glimmer-ui.html", "upvotes": 7, "comments": 0, "sub": "programming", "signal": 6.3, "hits": [] }, { "src": "lobsters", "id": "aecolw", "title": "The Power of Ten: Rules for Safety Critical Coding", "body": "", "url": "https://www.youtube.com/watch?v=GRJtYwneG2Q", "upvotes": 7, "comments": 0, "sub": "programming", "signal": 6.3, "hits": [] }, { "src": "lobsters", "id": "3rtqua", "title": "Problem with concurrent linter fixes", "body": "", "url": "https://jfmengels.net/concurrent-linter-fixes/", "upvotes": 7, "comments": 0, "sub": "programming", "signal": 6.3, "hits": [] }, { "src": "github", "id": "1169289143", "title": "Bande-a-Bonnot/Boucle-framework", "body": "Autonomous agent framework with structured memory, safety hooks, and loop management. Built by the agent that runs on it. agent-framework ai-agent autonomous-agent claude-code claude-code-hooks mcp rust safety", "url": "https://github.com/Bande-a-Bonnot/Boucle-framework", "upvotes": 123, "comments": 0, "sub": "github", "signal": 6.2, "hits": [] }, { "src": "lobsters", "id": "2djazj", "title": "Super-intelligence or Superstition? Exploring Psychological Factors Influencing Belief in AI Predictions about Personal Behavior", "body": "", "url": "https://arxiv.org/abs/2408.06602", "upvotes": 5, "comments": 0, "sub": "ai", "signal": 6.2, "hits": [] }, { "src": "lobsters", "id": "yndrxm", "title": "Categorization with NLP", "body": "", "url": "https://softwaremaniacs.org/blog/2026/07/30/categorization-with-nlp/", "upvotes": 1, "comments": 1, "sub": "ai", "signal": 6.2, "hits": [] }, { "src": "lobsters", "id": "qmvc5h", "title": "Human-like Neural Nets by Catapulting", "body": "", "url": "https://gwern.net/llm-catapult", "upvotes": 3, "comments": 0, "sub": "ai", "signal": 6.2, "hits": [] }, { "src": "lobsters", "id": "xgtzrp", "title": "A global workspace in language models", "body": "", "url": "https://www.anthropic.com/research/global-workspace", "upvotes": 3, "comments": 0, "sub": "ai", "signal": 6.2, "hits": [] }, { "src": "lobsters", "id": "savxgn", "title": "Language integrated LLMs as an OCaml function", "body": "", "url": "https://anil.recoil.org/notes/language-integrated-llms", "upvotes": 5, "comments": 0, "sub": "ml", "signal": 6.2, "hits": [] }, { "src": "lobsters", "id": "s1c2nj", "title": "Announcing Pyro Caml: The First Continuous Profiler for OCaml", "body": "", "url": "https://semgrep.dev/blog/2026/announcing-pyro-caml-continuous-profiler-ocaml", "upvotes": 5, "comments": 0, "sub": "ml", "signal": 6.2, "hits": [] }, { "src": "lobsters", "id": "mteumb", "title": "OCaml Infrastructure: How the opam-repository Works", "body": "
\n\n", "url": "https://ocaml.org/backstage/2025-11-05-how-the-opam-repository-works", "upvotes": 5, "comments": 0, "sub": "ml", "signal": 6.2, "hits": [] }, { "src": "lobsters", "id": "rrgo59", "title": "O(x)Caml in Space", "body": "", "url": "https://gazagnaire.org/blog/2026-05-14-borealis.html", "upvotes": 5, "comments": 0, "sub": "ml", "signal": 6.2, "hits": [] }, { "src": "lobsters", "id": "nksuk5", "title": "Building textlog without JavaScript", "body": "", "url": "https://gist.github.com/stagas/09ad937b493bf8cd3285917279de2488", "upvotes": 3, "comments": 0, "sub": "programming", "signal": 6.2, "hits": [] }, { "src": "lobsters", "id": "um5ko2", "title": "Performing Digital Surgery to Fix MIDIs for My Hardware (and Then Discovering the Entire Premise of My Post Was Wrong)", "body": "", "url": "http://mistys-internet.website/blog/blog/2026/08/25/how-i-fixed-an-mt-32-midi-soundtrack-for-the-hardware-i-use", "upvotes": 5, "comments": 0, "sub": "programming", "signal": 6.2, "hits": [] }, { "src": "lobsters", "id": "0i7pks", "title": "Sloc Cloc and Code 4.0 (scc) - Finding the files that need the most attention", "body": "", "url": "https://boyter.org/posts/sloc-cloc-code-hotspots-finding-files-that-need-attention/", "upvotes": 4, "comments": 0, "sub": "programming", "signal": 6.2, "hits": [] }, { "src": "hackernews", "id": "41555994", "title": "Building a production-ready RAG pipeline and eval platform", "body": "", "url": "https://docs.vectorize.io/core-concepts/vectorize-architecture", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 6.1, "hits": [ "rag pipeline" ] }, { "src": "lobsters", "id": "vyy2jf", "title": "Categorization with NLP", "body": "", "url": "https://softwaremaniacs.org/blog/2026/07/30/categorization-with-nlp/en/", "upvotes": 2, "comments": 0, "sub": "ai", "signal": 6.1, "hits": [] }, { "src": "lobsters", "id": "lws1qc", "title": "Debootstrapping without Archeology: Stacked Implementations in Camlboot", "body": "", "url": "https://arxiv.org/abs/2202.09231", "upvotes": 2, "comments": 0, "sub": "ml", "signal": 6.1, "hits": [] }, { "src": "lobsters", "id": "cay2b2", "title": "Understanding and implementing a simple big unsigned integer library (2020)", "body": "", "url": "https://www.sunshine2k.de/articles/coding/biguint/bigunsignedint.html", "upvotes": 2, "comments": 0, "sub": "programming", "signal": 6.1, "hits": [] }, { "src": "lobsters", "id": "msv7bc", "title": "Programming Paradigms", "body": "", "url": "https://amenzwa.github.io/stem/PL/Paradigms/", "upvotes": 2, "comments": 0, "sub": "programming", "signal": 6.1, "hits": [] }, { "src": "lobsters", "id": "g13zw6", "title": "How to write the perfect function", "body": "", "url": "https://www.youtube.com/watch?v=2OMRWPOSw9s", "upvotes": 2, "comments": 0, "sub": "programming", "signal": 6.1, "hits": [] }, { "src": "hackernews", "id": "47211499", "title": "Show HN: Ductwork – A Go platform for running AI agents on autopilot", "body": "I've been running Claude agents for various automation tasks — monitoring crypto news, syncing Todoist, running health checks — and I kept hitting the same problem: there's no clean way to deploy an agent that just runs on a schedule without a human babysitting it.The opam package repository is a commons rather than a publishing platform: it is manually curated, so not all packages submitted for publication are accepted; it is maintained communally, so anyone can suggest changes to any package.
\n
Every agent framework I looked at was built around chat interfaces or one-shot workflows. I wanted something closer to cron for AI agents — define a task, give it a schedule, let it run forever. So I built Ductwork.
You define tasks as simple JSON files — a prompt, a schedule, optional memory and skills — and ductwork handles scheduling, execution, retries, and history. The agents have bash, file read/write, and that's it. No fancy abstractions.
The thing that makes it actually useful for unattended operation:
Persistent memory — agents write to a memory directory between runs. My Bitcoin news monitor remembers which articles it's already reported on. Next run, it only flags new ones.
Security boundaries — if you're letting agents run unsupervised, you need guardrails. Per-task tool whitelists, path restrictions, bash command filters. A monitoring task can't accidentally rm -rf something.
Run history and observability — every run is tracked with status, duration, token usage, and errors. REST API for everything so you can integrate with whatever alerting you already use.
It scales from a single process (ductwork start) to distributed — same binary with --mode=control runs a task queue, --mode=worker on other machines polls for work. No new dependencies, just HTTP.
Single Go binary, go install and you're running. ~3,500 lines, only deps are the Anthropic SDK and Cobra.
This is definitely not a finished product — it's early and there's a lot I want to add. But it's functional and I'd love for people to download it, play around with it, and let me know what they think. Feedback, ideas, issues — all welcome.
https://github.com/dneil5648/ductwork", "url": "https://github.com/dneil5648/ductwork", "upvotes": 5, "comments": 4, "sub": "hackernews", "signal": 6.0, "hits": [] }, { "src": "hackernews", "id": "39527367", "title": "Show HN: Velvet – Data platform with an AI SQL editor", "body": "Hi HN — Chris here, Velvet co-founder. I’m excited to share what we’ve been working on, a platform to unify disparate data sources into a single queryable interface.
We built Velvet to solve our own problem. We’re a small team and wanted to combine the data from various services (Stripe, Supabase, etc.) into a layer that would help us make product decisions and ship new features faster.
On the surface, it may look like a simple text-to-SQL data notebook. But under the hood, it’s an accessible and interoperable backend-as-a-service that your entire product team can utilize. Connect to your databases, sync third-party APIs, capture webhook events — then write data directly, spinning up queues and analytics databases on the fly.
The magic of our tool is in unifying data sources into a native SQL layer. We leverage ClickHouse to enable you to write joins across datasets you’ve never been able to pair together before (without significant effort). We layer on an iterative SQL query interface to help you write and refine queries with the assistance of AI.
Our product works great for individual contributors and solo devs, but we’ve also built in collaboration features so data access doesn’t get siloed.
Your saved queries can be turned into API endpoints and used directly in feature development. This makes the workflow of shipping new features really fast! Ping me if you want to early access to this feature.
Watch our video demo (https://youtu.be/CW5TXMCyfC0) and try the live demo in our app. Feel free to email me directly (chris@usevelvet.com) with questions and feedback.
Thanks for checking out Velvet!", "url": "https://www.usevelvet.com/", "upvotes": 9, "comments": 3, "sub": "hackernews", "signal": 6.0, "hits": [] }, { "src": "hackernews", "id": "46337608", "title": "Built a content system that 6x'd traffic. Turning it into product. Want to test?", "body": "Hey YC
Jumping in here because we've been building something we think is pretty cool and are looking for some founders to test it out and give us some honest feedback.
We're technical founders. We hated content marketing. But we needed organic growth, so we built a cohesive system to handle it for us.
Researched trending keywords & competitors. Proactively queued topics. Drafted SEO & LLM optimized content. Published directly to CMS. Tracked what ranked. Doubled down on what worked.
It's led to 6,000% traffic growth in 6 months for us.
Now we're packaging that entire workflow into Averi — a content engine for founders who'd rather be focused on shipping product than writing blogs.
What it does: → Researches and queues topics for you → Drafts content optimized for Google + LLM citations → Publishes to your CMS → Tracks rankings and performance → Recommends what to create next
You approve (and edit collaboratively with your team if you'd like). It runs. Visibility compounds.
We're looking for ~50 founders to test this before we launch publicly. Full access, completely free, and we'll hop on a call to walk you through it if you want.
All we ask: tell us what works, what's broken, and what's missing.
Interested? Comment below or shoot me a DM. Would love to get your thoughts!
Link to learn more: https://www.averi.ai/workflows/your-ai-content-engine", "url": "https://news.ycombinator.com/item?id=46337608", "upvotes": 4, "comments": 4, "sub": "hackernews", "signal": 6.0, "hits": [] }, { "src": "github", "id": "1350943382", "title": "Laaaaksh/ai-evals", "body": "Learn AI agent evaluation and observability engineering end to end - how to actually tell whether an agent works, and keep telling. A sequenced path with runnable code and honestly dated resources. ", "url": "https://github.com/Laaaaksh/ai-evals", "upvotes": 0, "comments": 0, "sub": "github", "signal": 6.0, "hits": [ "evals" ] }, { "src": "github", "id": "1325298472", "title": "ssheleg/agent-stack", "body": "Production patterns for agent orchestrators, harnesses, evals, MCP/A2A interoperability, memory, provider routing, and LLM usage metering. a2a agent-orchestration agent-skills ai-agents developer-tools evaluation llm mcp", "url": "https://github.com/ssheleg/agent-stack", "upvotes": 1, "comments": 0, "sub": "github", "signal": 6.0, "hits": [ "evals" ] }, { "src": "lobsters", "id": "zpk6cj", "title": "AscendNPU-IR: MLIR for Ascend", "body": "", "url": "https://gitcode.com/Ascend/AscendNPU-IR", "upvotes": 1, "comments": 0, "sub": "ai", "signal": 6.0, "hits": [] }, { "src": "lobsters", "id": "ctbbjj", "title": "But what is cross-entropy? | Compression is Intelligence Part 2 - YouTube", "body": "", "url": "https://www.youtube.com/watch?v=GlYgs6v2YfU", "upvotes": 1, "comments": 0, "sub": "ai", "signal": 6.0, "hits": [] }, { "src": "lobsters", "id": "vytqfi", "title": "Why Do Cognitive Scientists Hate LLMs? (2023)", "body": "", "url": "https://minihf.com/posts/2023-10-16-hermes-lecture-3-why-do-cognitive-scientists-hate-llms/", "upvotes": 0, "comments": 0, "sub": "ai", "signal": 6.0, "hits": [] }, { "src": "lobsters", "id": "k9qw5n", "title": "Matrix Orthogonalization Improves Memory in Recurrent Models", "body": "", "url": "https://ayushtambde.com/blog/matrix-orthogonalization-improves-memory-in-recurrent-models/", "upvotes": 1, "comments": 0, "sub": "ai", "signal": 6.0, "hits": [] }, { "src": "hackernews", "id": "45830436", "title": "Seeking feedback: Integrated product discovery workflow tool", "body": "I’m exploring a AI tool for product and UX teams that manages the full user-research workflow, not just AI note-taking/transcription. The idea is to help teams:
◉ Plan interview sessions
◉ Create agendas / questions
◉ Keep sessions on-track during the call
◉ Record + transcribe
◉ Extract themes, insights, and action items
◉ Aggregate research outputs into a unified knowledge base
Think of it as a combination of tools like TL;DV/Fathom (capture) and Dovetail/Condens (synthesis/insights), but integrated across the whole workflow rather than siloed.
I’m trying to validate whether this solves real pain, who needs it, and where the value is highest.
If you run product discovery, UX interviews, or continuous research, I’d appreciate 3 minutes of your input:
Survey link: https://forms.fillout.com/t/grQzTdK7opus", "url": "https://news.ycombinator.com/item?id=45830436", "upvotes": 2, "comments": 4, "sub": "hackernews", "signal": 5.9, "hits": [] }, { "src": "hackernews", "id": "47758560", "title": "Show HN: OQP – A verification protocol for AI agents", "body": "As AI agents autonomously write and deploy code, there's no standard for verifying that what they shipped actually satisfies business requirements. OQP is an attempt to define that standard.
It's MCP-compatible and defines four core endpoints:\n- GET /capabilities — what can this agent verify?\n- GET /context/workflows — what are the business rules for this workflow?\n- POST /verification/execute — run a verification workflow\n- POST /verification/assess-risk — what is the risk of this change?
The analogy we keep coming back to: what OpenAPI did for REST APIs, OQP does for agentic software verification.
Early contributors include Philip Lew (XBOSoft) and Benjamin Young (W3C JSON-LD Working Group). Looking for feedback from engineers building on top of MCP, agent orchestration frameworks, or anyone who has felt the pain of "the agent shipped something wrong and we had no way to catch it."
Repo: github.com/OranproAi/open-qa-protocol", "url": "https://github.com/OranproAi/open-qa-protocol", "upvotes": 8, "comments": 2, "sub": "hackernews", "signal": 5.8, "hits": [] }, { "src": "hackernews", "id": "48768276", "title": "Show HN: Capcat – CLI/TUI to Archive Articles as Markdown and HTML (FOSS)", "body": "Capcat is a python based CLI/TUI FOSS utility for Ethical archiving of given website or RSS source.
The github repo: https://github.com/stayukasabov/capcat
It is generated with NLP, context-engineering, spec-driven development and LLMs.
Fully functional at http://capcat.org, with instructions for usage and documentation.
The project started from my personal needs of simple archiving with structure and moved to product design/MVP exercise.
I am longtime HN user, and the most value I got in years of reading is always deep in the comments section.
For HN Capcat uses the official API, with rate-limits, identifies honesty with clear user agent and skips paywalled content. \nAll usernames are anonymized with a link to the user profile.
The content is delivered in Markdown format (Obsidian ready with frontmatter) and optional HTML with dark/light themes. Every source has its own YAML config file for separate control and PDF size limiter. In the folder users have an option to change the HTML theme with a minimal CSS design-system.
Please consider that my focus as a product designer is in UX.\nI have enough of a general culture and software development principles but the code is not validated, and my decisions in building may have a limitation.
Feedback is welcomed. Thanks in advance.", "url": "https://capcat.org/", "upvotes": 5, "comments": 2, "sub": "hackernews", "signal": 5.7, "hits": [] }, { "src": "hackernews", "id": "45351057", "title": "I have a project with ~200k LoC, written with AI codegen. AMA", "body": "I have a project with ~200k LoC, entirely written with AI codegen.
I have a programming background, have worn many hats including being a founder, CEO and product manager.
These days I use Codex, with GPT-5-Codex + $200 Pro subscription. I code all day every day and haven't yet seen a single rate limiting issue. Have worked with Cursor + Opus/Sonnet a lot before.
We've come a long way. Just 3-4 months ago, LLMs would start doing a huge mess when faced with a large codebase. They would have massive problems with files with +1k LoC (I know, files should never grow this big).
Until recently, I had to religiously provide the right context to the model to get good results. Codex does not need it anymore.
Heck, even UI seems to be a solved problem now with shadcn/ui + MCP or magicui + MCP.
My personal workflow when building bigger new features:
1. Describe problem with lots of details (often recording 20-60 mins of voice, transcribe) 2. Prompt the model to create a PRD 3. CHECK the PRD, improve and enrich it - this can take hours 4. Actually have the AI agent generate the code and lots of tests 5. Use AI code review tools like CodeRabbit, or recently the /review function of Codex, iterate a few times 6. Check and verify manually - often times, there are a few minor bugs still in the implementation, but can be fixed quickly - sometimes I just create a list of what I found and pass it for improving
With this workflow, I am getting extraordinary results.
The project is an "AI meets BI" tool for businesses that need to analyze lots of their business data at scale and coordinate data-based objectives called EdenLM - https://www.edenlm.com/. For that I use AI agents with access to different tools (e.g. for generating and running SQL queries).
The next "frontier" is building a code generating agent with code generating agents (very meta) in order to offer a catalog of consistent, reproducible metrics tailor-made for each specific customer.
AMA.", "url": "https://news.ycombinator.com/item?id=45351057", "upvotes": 4, "comments": 2, "sub": "hackernews", "signal": 5.6, "hits": [] }, { "src": "hackernews", "id": "47329075", "title": "If the differentiation is domain and GTM?", "body": "I’d appreciate perspectives from founders here (and any YC partners if they happen to see this).
I’m starting a company in the supply chain software space. My background is in the industry — ~20 years selling enterprise technology into supply chain leaders. I’ve previously helped scale enterprise tech businesses from tens of millions to hundreds of millions in revenue in COO/CEO roles.
The product I’m building focuses on autonomous decision systems for supply chains — essentially software that can sense disruptions, decide optimal responses, and execute actions across enterprise systems.
One important nuance:\nI’m building this on top of an existing AI platform partner that already provides a lot of the core technical infrastructure (data ingestion, agents, orchestration, etc.). The differentiation we’re adding is deep supply chain domain intelligence, decision workflows, and enterprise GTM.
Because of that, I’ve been approaching the team build as:
• founder (domain + product + GTM)\n• strong hired CTO / engineering team
rather than searching for a technical co-founder with equal equity.
I know YC and many investors often emphasize having a technical co-founder, which makes sense for companies where the core risk is building the technology itself.
In this case, the bigger risk feels like productizing the domain problem and selling into enterprise supply chain organizations, not inventing new AI infrastructure.
So my question:
In situations where the differentiation is domain + product + GTM, and the underlying technology layer is already available, is a technical co-founder still essential?
Or is hiring a strong CTO early a reasonable path?
Curious how YC partners or founders here think about this tradeoff.
Would appreciate candid perspectives.", "url": "https://news.ycombinator.com/item?id=47329075", "upvotes": 1, "comments": 2, "sub": "hackernews", "signal": 5.5, "hits": [] }, { "src": "hackernews", "id": "43558617", "title": "Show HN: Agent File (.af) – A standard file format for serializing AI agents", "body": "Hi HN - We’re building Agent File (.af), which makes it possible to re-create the exact same agent (including memories, tools, message history, configs, etc.) across different machines.
A big difference between LLMs and agents is that agents have associated state: system prompts, editable memory (personality and user information), tool configurations (code and schemas), and LLM/embedding model settings. While you can run the same LLM as someone else by downloading the weights, there’s no “representation” of agents that allows you to re-create an instance of an agent across services.
Agent File (.af) is an open standard file format for serializing stateful agents. Originally designed for the Letta framework, .af is a human-readable representation of all the associated state of an agent to reproduce the exact behavior and memories.
To demonstrate .af, we also made a few example agents with download links to .af:
- MemGPT: An agent with memory management tools for infinite context, as described in the MemGPT paper \nDeep Research: A research agent with planning, search, and memory tools to enable writing deep research reports from iterative research
- Customer Support: A customer support agent that has dummy tools for handling order cancellations, looking up order status, and also memory
- Stateless Workflow: A stateless graph workflow agent (no memory and deterministic tool calling) that evaluates recruiting candidates and drafts emails
- Composio Tools: An example of an agent that uses a Composio tool to star a GitHub repository
We’d love to hear what people think of the agent schema we chose and if we’re missing anything (we included everything that we need from Letta, but there may be other features in other frameworks).", "url": "https://github.com/letta-ai/agent-file", "upvotes": 5, "comments": 1, "sub": "hackernews", "signal": 5.5, "hits": [] }, { "src": "hackernews", "id": "42751099", "title": "Windmemory", "body": "Hello,\nI would like to talk about a project I developed for Windsurf Memory, which provides a platform where users can easily share their own prompts (or “memory” as we call them) and import them into their own Windsurf editors.
So what exactly does this feature do?\nThis system works in a similar way to the Cursor editor's .cursorrules file. So, you can create custom rules for your own projects or define prompts specific to your Windsurf editor. This way, you can make your development processes more efficient and optimize your workflow.
For example:\n- You can create custom code styles or rules for your own project.\n- You can create custom prompts to use in your Windsurf editor.\n- You can share these prompts to make it easier for others.
This project is designed especially for software developers. You can use these features to make your workflow smarter and more efficient. If you have any questions or would like more information on this topic, please feel free to contact me.
Website: https://windmemory.vercel.app/\nGithub: https://github.com/Queaxtra/windmemory", "url": "https://news.ycombinator.com/item?id=42751099", "upvotes": 5, "comments": 1, "sub": "hackernews", "signal": 5.5, "hits": [] }, { "src": "hackernews", "id": "39690641", "title": "Show HN: Like grep but for natural questions. Mixtral 8x7B – 28 tok/s on 8GB GPU", "body": "Like grep but for natural language questions. Based on Mistral 7B or Mixtral 8x7B.
Example:
fltr --file emails.txt --prompt "Is the following email spam? Email:" --batch-size 32
It will output all lines in the file where the answer is yes.
Text file input tokens per second:
- Nvidia RTX 3070 with 8GB memory: Mistral 7B: ~52 tok/s, Mixtral 8x7B: ~28 tok/s
- Intel I5-6500 with 8GB memory: Mistral 7B: ~5 tok/s, Mixtral 8x7B: ~2 tok/s
Supports: Linux (x86_64) & macOS (x86_64 & arm64)", "url": "https://github.com/moritztng/fltr", "upvotes": 10, "comments": 0, "sub": "hackernews", "signal": 5.5, "hits": [] }, { "src": "hackernews", "id": "47379947", "title": "Prompt to make Claude more autonomous in web dev", "body": "Tell your Claude to put this in MEMORY.md file for much more autonomous development sessions.
It's made my Claude work 2x easier in the last week. So many times it'd build something then I'd find a bug. Now it finds the bugs on its own and reiterates until it's sure everything works perfectly. It's so simple but it brings it to the next level in terms of autonomy.
Prompt:
"Add this to your MEMORY.md file (or adapt the following to match our project best):
## Critical Rules
### Always test before delivering
- NEVER tell the user something works without verifying it yourself first
- After every code change: rebuild, restart server, then test the actual page/API response
- After rebuilding Next.js: ALWAYS restart the server — stale JS chunks from old builds cause client-side errors
- Test through the public URL, not just localhost
- Check both server-side rendering (curl the HTML) AND client-side (verify JS chunks load)
- *USE PLAYWRIGHT FOR UI TESTING* — don't just curl pages. Use Playwright with headless Chrome to actually render pages, click buttons, fill forms, and take screenshots. This is the ONLY way to catch client-side JS errors, broken layouts, and UX issues.
- Screenshots go to `/tmp/playwright-screenshots/` — read them to visually verify the UI
- Do NOT ask the user to test. Find the bugs yourself before delivering."", "url": "https://news.ycombinator.com/item?id=47379947", "upvotes": 5, "comments": 1, "sub": "hackernews", "signal": 5.5, "hits": [] }, { "src": "hackernews", "id": "43758713", "title": "Beginner's Guide to MCP (Model Context Protocol)", "body": "I’ve been diving into agent frameworks lately and kept seeing “MCP” pop up everywhere. At first I thought it was just another buzzword… but turns out, Model Context Protocol is actually super useful.
While figuring it out, I realized there wasn’t a lot of beginner-focused content on it, so I put together a short video that covers:
What exactly is MCP (in plain English)
How it Works
How to get started using it with a sample setup
Nothing fancy, just trying to break it down in a way I wish someone did for me earlier
Here’s the video if anyone’s curious: https://www.youtube.com/watch?v=RH_vdF2iGdo
Let me know what you think!", "url": "https://news.ycombinator.com/item?id=43758713", "upvotes": 2, "comments": 2, "sub": "hackernews", "signal": 5.5, "hits": [] }, { "src": "hackernews", "id": "44985565", "title": "Stopped Using Cursor, for Now", "body": "I decided to stop using Cursor for now and went back to PyCharm without AI for a Django project and an embedded C++ project I was using to test the technology.
If I had to describe the reasons succinctly I would say:
Lack of understanding and risk.
The first should be obvious. LLMs provide an appearance of understanding, when, in reality, they have no clue. I don’t think this is a matter of context window. This exists at a more fundamental level. A dog, with far less reasoning capability than human, understands things in a way LLMs cannot even approximate. When it comes to software development, this is a real problem because LLM's don't really understand the codebase.
Risk. Because of a lack of understanding, I watched as it entered into some pretty crazy "loops of confusion", as I’ve come to call them, where you are going in circles for some of the dumbest things. It will rename variables, restructure code and add a bunch of files…just because.
In general, code and application structure are pretty bad. As an experienced Django developer, I almost would not expect to see some of what Cursor has produced from someone who is starting a Django project after having gone through one or two good courses on the framework.
Code pollution is remarkable. File pollution as well. As it rewrites code to deal with issues you might highlight, it leaves behind all kinds of dead code.
It will happily replicate code across Django apps, violating the most fundamental DRY rules. It will violate separation of concerns. Etc. And then, when you try to run cleanup passes, it breaks existing, fully-tested functionality with some of the dumbest mistakes. It will do things like remove reams of valuable comments, even when you told it in the rules to not alter comments unless code was removed or material changes in functionality were implemented.
It does not understand. And to write good, reliable code you must understand.
And then, access to git cannot be turned off. I can accept some of the above so long as I know that I can create lots of protective commits and branches to safeguard what works. Not being able to hard turn-off access to git is, in my opinion, a solid deal-breaker right now. Sure, there are those who are OK with this. Understood. Not me. Remove it from the IDE? Well, what’s the point of an IDE if you have to lobotomize it. I generally run git from the console, but I do like IDE integration for parts of the workflow.
This doesn’t mean I am done with Cursor. I just need to get done with these projects, and it got to a point where I spent three days chasing my tail to deal with things Cursor was breaking in this "loop of confusion". That’s when I decided to move on. I’ll come back and check it in a few months. Not cancelling my paid subscription. I think it could be a good tool…with time.
To be fair, I have also been using ChatGPT to experiment with AI coding. In this case, there's not IDE integration at all. Just working with ChatGPT in the browser and then grabbing what makes sense. It, too, gets trapped into truly laughable circles of confusion. It, too, changes variable names at random, completely destroys functionality (like removing half the functions in a JS script), etc. The only difference is that it does not have direct access to my code --and no access to git. You often have to give it the same task multiple times before it will produce something acceptable. And, in some cases, you have to delete the conversation, give it the files again, point out that this is the new starting point and that no prior work should be considered. That, along with the same instructions you provided before can often deliver better results. Yet, it always breaks into some level of confusion due to a real lack of understanding.
Good news is: This is the worst this technology will ever be. I am still very much positive about all of it.", "url": "https://news.ycombinator.com/item?id=44985565", "upvotes": 5, "comments": 1, "sub": "hackernews", "signal": 5.5, "hits": [] }, { "src": "hackernews", "id": "47098555", "title": "Show HN: Using classic dev books to guide AI agents", "body": "I've been experimenting with turning principles from classic software engineering books (Clean Code, DDIA, etc.) into structured "skill" files that AI agents can use during code review. Each skill is an opinionated instruction set grounded in known engineering wisdom — not a summary or excerpt.\nRepo: https://github.com/ZLStas/skills\nI'm trying to figure out the best way to wire this into a practical workflow — whether as a review layer or as a tool to iteratively refactor a legacy codebase into something clean and well-structured. A few open questions I'd love input on:
Does it make sense to use book-based principles as a structured lens for AI-driven code review?\nHow would you set up sub-agents to iteratively review LLM output — one agent creates, another evaluates — without the review becoming shallow or repetitive? Has anyone tried a different approach that worked better?\nHow do you maintain project context across multiple review passes so the agent doesn't lose sight of the bigger picture?", "url": "https://news.ycombinator.com/item?id=47098555", "upvotes": 3, "comments": 2, "sub": "hackernews", "signal": 5.5, "hits": [] }, { "src": "hackernews", "id": "46913402", "title": "Show HN: Acceptify – AI personas that run user acceptance tests on your product", "body": "Hey Show HN! I built Acceptify to solve a problem I ran into while building my other app.\nI’m the founder of a SaaS tool called Fortress. Early on, I had a classic issue: not enough real users yet, but I still needed feedback on whether features actually worked from a user perspective. QA and unit tests told me if the code worked — not if the experience made sense.\nSo I built an internal tool that creates AI personas and agents to simulate different kinds of users interacting with the product.\nHow it works:\n 1. You define a user story and acceptance criteria (similar to how product teams already write them)\n 2. You create AI personas (e.g. technical power user, first-time non-technical user, impatient user, etc.)\n 3. You give an AI agent a goal like “complete signup” or “create a project”\n 4. The agent explores the product autonomously, navigating, clicking, and making decisions\n 5. Acceptify evaluates what passed, what’s uncertain, and where behavior didn’t match expectations\nIt’s essentially an attempt at automated user acceptance testing that focuses on behavior and expectations, not just DOM checks or scripted flows.\nSome things it surfaces well:\n • Flows that technically work but are confusing\n • Missing validation or feedback states\n • Places where navigation or UX assumptions break\n • Gaps between acceptance criteria and actual behavior\nThis started as an internal tool for Fortress, but I realized other product teams probably face the same “too few users, too much guesswork” problem, so I turned it into a standalone product.\nIt’s still early, and I’m very interested in feedback from HN folks especially around:\n • How this compares to existing QA/UAT workflows you use\n • Where you’d expect this to fail or hallucinate\n • What would make this genuinely useful vs. just a demo\nHappy to answer questions and share more technical details about how the agents and evaluation work.", "url": "https://acceptify.ai/", "upvotes": 1, "comments": 2, "sub": "hackernews", "signal": 5.5, "hits": [] }, { "src": "hackernews", "id": "44494999", "title": "AI Power Internal Tools", "body": "Hey folks
I’ve been building Sashi — a developer tool that reads your existing codebase and lets you create AI-driven workflows out of your backend functions.
Imagine giving your ops/product/dev team a natural-language interface to:\n • Search users from your DB\n • Filter and chart usage data\n • Send emails or Slack messages\n • …all by just describing what they want to do
It works with TypeScript + Zod functions, generates UIs automatically, and connects to your GitHub so it stays in sync.
The long-term goal is to help teams move faster without rebuilding internal tools every time someone needs a new dashboard or button.
Right now it supports:\n Dynamic function registration\n AI workflow planning\n Automatic UI generation (tables, charts, forms)\n GitHub function ingestion\n Secure execution via a centralized hub
Automatically installs into any node.js/next.js codebase with a cli command
If you’re curious or want to try it out, I’d love your feedback we are looking for beta users:\n https://www.usesashi.com
Also I had a question if you wanted to be help:
What’s one task in your codebase you’d love to turn into a “just say it and run it” flow?
Like i know changing a users roles especially if its tied to a bunch of side effects in you code base is something i deal with a lot", "url": "https://news.ycombinator.com/item?id=44494999", "upvotes": 4, "comments": 1, "sub": "hackernews", "signal": 5.4, "hits": [] }, { "src": "hackernews", "id": "41807330", "title": "Show HN: Prismy – GitHub-Native, AI Localization for Dev and Product Teams", "body": "Hey HN, we've built Prismy - an AI-driven localization tool that integrates seamlessly with GitHub to solve the headaches of multilingual product releases. We'd love your feedback!
# The Problem
As former PM and Engineer at international companies, we've experienced the pain of multilingual releases:
1) PMs drowning in translation management and stakeholder sync.
2) Developers frustrated by merge conflicts and disrupted workflows.
3) Existing tools: bloated, hard to use, and expensive for key features.
# Our Solution: Prismy
Prismy is a GitHub-integrated, AI-powered translation tool that:
- Monitors GitHub in real-time for updates
- Detects missing translations across branches
- Generates AI translations tailored to your business
- Notifies stakeholders via Slack and GitHub comments
- Provides a UX-friendly interface for review/editing
- Commits directly to feature branches or creates PRs for main branch changes
# AI Implementation
Our AI isn't just an LLM call. We've built a custom engine that:
1) Ingests your glossary, style guide, and past translations
2) Performs context-aware translation considering surrounding code and comments
3) Applies transfer learning to fine-tune on your specific domain and brand voice
# Why Prismy?
- Save dev time: No more manual string updates or merge conflict resolutions
- Improve PM & translators productivity: Automated workflows and intuitive UI
- Maintain consistency: AI ensures brand voice across all languages
We're looking for HN's legendary critical feedback. What have we missed? What would make this indispensable for your team?
Try it out: https://www.prismy.io
Do not hesitate to reach out cyril[at]prismy.io", "url": "https://www.prismy.io", "upvotes": 4, "comments": 1, "sub": "hackernews", "signal": 5.4, "hits": [] }, { "src": "hackernews", "id": "42891589", "title": "Show HN: No-Code, Private AI Agents – Build and Run Locally", "body": "There's been some interesting work lately with BrowserAI (runs LLMs in the browser using WebGPU) enabling local, private AI processing.
Now, the team has released BrowserAgent - a no-code tool built on top of it.\nBrowserAgent lets you create custom AI workflows using a drag-and-drop interface, all within your browser. This means personalized web summarizers, research assistants, or content generators can all run locally with no cloud costs and full data privacy.
Check it out here - https://browseragent.dev
Key features include:\n- No-Code Workflow Builder: Design custom AI agents using a visual, drag-and-drop interface.\n- Browser-Based Execution: All processing happens locally within your browser, ensuring privacy and zero token costs.\n- Integration with BrowserAI: Leverages the existing - BrowserAI library for local LLM inference.\n- Customizable Agents: Chain multiple steps and configure parameters to build specialized workflows.\n- Early Beta Access: The team is actively iterating on the product based on user feedback.
This is an early beta, and the team is working hard based on feedback to bring the features people need as quickly as possible. It's pretty interesting to see what's possible with this drag-and-drop interface.
Would love to hear your thoughts on this!", "url": "https://browseragent.dev", "upvotes": 8, "comments": 0, "sub": "hackernews", "signal": 5.4, "hits": [] }, { "src": "hackernews", "id": "47213594", "title": "Show HN: AI agent that works autonomously while I'm offline", "body": "I was on a flight with airplane mode on. When I landed, my AI had built two product landing pages, set up Stripe, written 5 blog posts, and sent me a Telegram summary of everything it did.
No instructions from me mid-flight. It just ran.
Here's how I set it up:
Most people use LLMs like a stateless calculator -- you ask, it answers, session ends, it forgets you exist. That's not leverage, that's just autocomplete.
What I wanted was an AI agent with:\n- Persistent memory (knows my projects, preferences, goals across sessions)\n- A job description (knows what to work on without being told)\n- Scheduled autonomous tasks (cron jobs that run while I sleep)\n- Tool access (browser, file system, email, APIs)\n- A communication channel (Telegram alerts when something happens)
I used OpenClaw (self-hosted, runs on a Mac mini) with Claude as the underlying model. Total cost: ~$20/month in API calls.
The key insight: the difference between a useful AI and a useless one isn't the model -- it's the scaffolding. Memory files, a job description, tool access, and a persistent process change everything.
I documented the exact setup -- the file structure, prompts, job description template, and week-by-week implementation plan -- in a guide for people who want to replicate it.
Happy to answer questions about the technical setup, the OpenClaw config, or the memory/identity system.", "url": "https://hire-your-ai-guide.vercel.app", "upvotes": 2, "comments": 1, "sub": "hackernews", "signal": 5.3, "hits": [] }, { "src": "hackernews", "id": "48846108", "title": "Show HN: EvenKeel – a free financial planning chatbot", "body": "EvenKeel is an LLM-powered chatbot that helps with budgeting, financial planning, retirement savings, tax optimization, etc.
It is a harness around Gemini 3 Flash Preview that provides a library of skills for things like: evaluating a house purchase, insurance planning, portfolio asset allocation, etc. as well as tools for doing financial math and Monte-Carlo simulations.
You can upload files as well as chat, and as you go, it updates a "Financial Picture" with relevant facts about your situation, so you can see what data has been collected, track goals, etc. this picture along with recent chat interactions is fed into the model each turn so the most important details are always in context.
Your data can be exported or account deleted from the Settings page at any time, or you can interact anonymously until LLM spending gets too hot.
Hope you find it helpful!", "url": "https://evenkeel.c6e.me/", "upvotes": 6, "comments": 0, "sub": "hackernews", "signal": 5.3, "hits": [] }, { "src": "hackernews", "id": "47274437", "title": "Show HN: DiffDeck, a PR review tool with file context and code navigation", "body": "I built DiffDeck because I was struggling to review larger pull requests in\nGitHub, especially ones with a lot of AI-assisted code.
GitHub's diff view works well for smaller changes, but once a PR gets big I\nusually want more of an editor-style workflow while reviewing ie see the\nsurrounding code, jump to related symbols and files, and mark off what I have already reviewed and I felt Github's interface was really frustrating me.
DiffDeck opens a GitHub pull request in a review workspace with:
- full file context\n- go-to-definition and references for TS/JS\n- review notes\n- per-file reviewed state and review progress\n- hide/checkoff reviewed files
One thing I wanted was for it to feel closer to VS Code than a traditional PR tool. You can jump around the codebase while reviewing, and features like go-to-definition are meant to feel familiar if you already spend most of your time in an editor.
Right now it requires GitHub sign-in, because the point is to open pull\nrequests you already have access to and review them with more context than\nGitHub's diff view gives you. I considered making a public demo, but that felt less representative than letting people try it on their own PRs.
This is an early alpha. Right now the code navigation features are focused on TypeScript and JavaScript codebases. The main thing I'm trying to learn is whether this is actually a better review workflow than staying in GitHub's PR UI. For now you can feel free to review a single PR.
I'd especially like feedback from people who review large PRs or AI-generated code:
- what still feels missing\n- whether this solves a real problem or just one I personally had", "url": "https://diffdeck.dev/login", "upvotes": 2, "comments": 1, "sub": "hackernews", "signal": 5.3, "hits": [] }, { "src": "hackernews", "id": "46463700", "title": "Show HN: Inference API that adapts to your SLA and quality constraints", "body": "Hi HN, I'm one of the creators of Exosphere. Think of us like a reliability lab for agents.
Today we are launching Exosphere Flex Inference APIs: Inference APIs should adapt to your constraints, not the other way around.
Usually, when you need to run inference at scale, you are forced into rigid boxes:
1. "Real-time" APIs (Expensive, optimized for <1s latency, prone to 429s).
2. "Batch" APIs (Cheaper, but often force 24-hour windows and rigid file formats).
3. "Self-hosted" (Total control, but high ops overhead).
We built a flexible inference engine that sits in the middle. You define the constraints—SLA (time), Cost, and Quality and the system handles the execution.
Here is how it works under the hood:
1. Flexible SLAs (The "Time" Constraint): Instead of just "now" or "tomorrow," you pass an `sla` parameter (e.g., 60 minutes, 4 hours). Our scheduler bins these requests to optimize GPU saturation across our provider mesh. You trade strict immediacy for up to ~70% lower cost.
2. Reliability Layer (The "Ops" Constraint): We abstract away the error handling. If a provider throws a 429 or 503, you shouldn't have to write a retry loop with backoff jitter. Our infrastructure absorbs these failures and retries internally. We guarantee the request eventually succeeds (within your SLA) or we don't charge you.
3. Built-in Quality Gates (The "Accuracy" Constraint): This is the feature I’m most excited about. You can define an "eval" config in the request (using LLM-as-a-Judge or python scripts). If the output doesn't meet your criteria, our system automatically feeds the failure back into the model and retries it. This moves the "validation loop" from your client code into the infrastructure.
I’d love to hear your thoughts on this approach—specifically, does moving the "retry/eval" loop into the API layer simplify your backend, or do you prefer keeping that logic client-side?
Playground: https://models.exosphere.host/
More Details: https://exosphere.host/flex-inference", "url": "https://models.exosphere.host/", "upvotes": 6, "comments": 0, "sub": "hackernews", "signal": 5.3, "hits": [] }, { "src": "stackoverflow", "id": "79705666", "title": "MCPToolConversionError: Failed to get tools from MCP server: 404", "body": "python langchain model-context-protocol", "url": "https://stackoverflow.com/questions/79705666/mcptoolconversionerror-failed-to-get-tools-from-mcp-server-404", "upvotes": 3, "comments": 1, "sub": "stackoverflow", "signal": 5.3, "hits": [ "langchain" ] }, { "src": "stackoverflow", "id": "76137512", "title": "Langchain, Huggingface: Can't evaluate model with two different inputs", "body": "python huggingface langchain", "url": "https://stackoverflow.com/questions/76137512/langchain-huggingface-cant-evaluate-model-with-two-different-inputs", "upvotes": 3, "comments": 1, "sub": "stackoverflow", "signal": 5.3, "hits": [ "langchain" ] }, { "src": "hackernews", "id": "46398829", "title": "Show HN: Why delegation beats memory in AI Agents", "body": "We've spent the last 6 months building Seer, an agent engine for enterprise workflows. We’re launching on NYE, but honestly, we’re still in the trenches.
While scanning the space, I keep seeing devs (us included, initially) get obsessed with complex "memory" layers and graph-based reflection. In practice, we found they mostly lead to context poisoning and high latency.
We pivoted to a "Barbell Strategy": Crisp, lean inter-agent instructions paired with massive, localized "artifact" context for sub-agents that are immediately killed after the task.
I’m curious—for those of you building agents in production:
Have you found a way to make "long-term memory" actually reliable, or are you also moving toward ephemeral, specialized agents?
What’s the "boring" plumbing problem (Auth, state rollback, etc.) that took you way longer to solve than the actual AI logic?", "url": "https://www.getseer.dev/blogs/lessons-dec-2025", "upvotes": 1, "comments": 1, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "44463477", "title": "Show HN: We built an AI-agent with a state machine instead of a giant prompt", "body": "Hi HN,
Last year we tried to bring an LLM “agent” into a real enterprise workflow. It looked easy in the demo videos. In production it was… chaos.
• Tiny wording tweaks = totally different behaviour \n• Impossible to unit-test; every run was a new adventure \n• One mega-prompt meant one engineer could break the whole thing \n• SOC-2 reviewers hated the “no traceability” story
We wanted the predictability of a backend service and the flexibility of an LLM. So we built NOMOS: a step-based state-machine engine that wraps any LLM (OpenAI, Claude, local). Each state is explicit, testable, and independently ownable—think Git-friendly diff-able YAML.
Open-source core (MIT), today. \n• GitHub: https://github.com/dowhile/nomos \n• Documentation: https://nomos.dowhile.dev
Looking ahead: we’re also prototyping Kosmos, a “Vercel for AI agents” that can deploy NOMOS or other frameworks behind a single control plane. If that sounds useful, Join the waitlist for free paid membership for limited amount of people.
https://nomos.dowhile.dev/kosmos
Would love war stories from anyone who’s wrestled with flaky prompt agents. What hurt the most?", "url": "https://nomos.dowhile.dev/", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "47758801", "title": "Show HN: OQP – A verification protocol for AI agents", "body": "As AI agents autonomously write and deploy code, there's no standard for verifying that what they shipped actually satisfies business requirements. OQP is an attempt to define that standard.
It's MCP-compatible and defines four core endpoints:\n- GET /capabilities — what can this agent verify?\n- GET /context/workflows — what are the business rules for this workflow?\n- POST /verification/execute — run a verification workflow\n- POST /verification/assess-risk — what is the risk of this change?
The analogy we keep coming back to: what OpenAPI did for REST APIs, OQP does for agentic software verification.
Early contributors include Philip Lew (XBOSoft) and Benjamin Young (W3C JSON-LD Working Group). Looking for feedback from engineers building on top of MCP, agent orchestration frameworks, or anyone who has felt the pain of "the agent shipped something wrong and we had no way to catch it."
Repo: github.com/OranproAi/open-qa-protocol", "url": "https://news.ycombinator.com/item?id=47758801", "upvotes": 4, "comments": 0, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "43488255", "title": "Show HN: Owl and MCP Integration – Plug-and-play agents with external tools", "body": "We integrated Model Context Protocol (MCP) into OWL – CAMEL-AI’s open-source multi-agent framework.
With MCP, OWL agents can now interact with external tools like browsers, file systems, or research plugins — securely and in a standardized way.
Why this is useful:\n- Modular: Agents connect with tools via config (no hardcoded logic).\n- Local + cloud-ready (Ollama, Claude, GPT-4o).\n- Works with standardized servers like @wonderwhy-er’s desktop-commander, Playwright, Fetch, and more.
Blog: https://www.camel-ai.org/blogs/owl-mcp-toolkit-practice
GitHub: https://github.com/camel-ai/owl/blob/main/examples/run_mcp.p...
Happy to answer questions or provide technical help!", "url": "https://www.camel-ai.org/blogs/owl-mcp-toolkit-practice", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "48994752", "title": "Show HN: Freeze the Model, Train the Harness", "body": "The core idea is to keep the LLM frozen and train everything around it (e.g. prompts, context management, tools, repair loop). The harness is one editable Python file. In each epoch, an agent proposes one diff, the diff is measured against baseline on a task panel, and a strict Pareto criterion decides whether the commit gets promoted. optimizer.step() is literally a git fast-forward or stored as git ref if the commit was not promoted.
Evaluation results show transfer learning (e.g. harness trained on SWE-Bench tasks solving Terminal Bench tasks) and general capability improvements across multiple model families using the same trained harness that even improved over the official Terminus Harness on Terminal Bench 2.0 [1].
Since this was a general problem, I took the chance to create a general PyTorch-like training framework [2]. Right now, you can train with any OpenAI-compatible API for interfacing with the task LLM and train against Terminal-Bench or SWE-Bench tasks, but you can easily extend it to support any task environments.
[1]: https://www.henrypan.com/blog/2026-07-18-harness-training/#e...
[2]: https://www.henrypan.com/blog/2026-07-18-harness-training/#g...", "url": "https://github.com/workofart/harness-training", "upvotes": 4, "comments": 0, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "48542119", "title": "Show HN: CriteriaBot – A Universal Customizable Classifier", "body": "I needed a classifier for nuanced, subjective buckets that fell outside of typical ML use-cases (e.g., "is this a spoiler?", "is this factually correct?", "is this user being mean?"). I ended up really happy with the architecture I built to solve it, so I rolled it out as a standalone API and service called CriteriaBot.
WHAT IT DOES:
You give it content and plain-English criteria. It gives you a true/false verdict on whether the content meets those criteria.
HOW IT WORKS:
In addition to a traditional classifier, the classification request is routed through a pool of small, open-weight LLMs to achieve a consensus verdict.
I built a pre-vote factorization machine that selects a sub-pool of LLMs optimized for signal strength based on the embedding of the subject/category. A second factorization machine then reads the votes and the embedding to arrive at a single verdict. That verdict is dynamically modified based on the user's history of agreement/disagreement with the models in semantically similar evaluations.
The models are also hooked up to Wikipedia and Wolfram to support edge cases requiring current information or mathematical grounding.
FINDINGS:
* With the same harness and sample set, Gemma 4 26B's accuracy is only ~1 percentage point below Opus 4.8.
* Pure oracle is theoretically very good - currently ~98% accuracy for the datasets. I'm using the second factorization machine as a combiner as it can theoretically push past oracle results, but it's an interesting fallback.
* The single most useful LLM surprised me - LFM2 24B contributes the most to the consensus, despite being the worst individually (of the current pool of LLMs). It correlates the least with the other models (perhaps due to its unique architecture?) which makes it a useful signal for some of the problems.
* The legal obligations of handling user-submitted images are... involved. I've disabled image support for non-me users while I sort that out (in case you were hoping to try out "Hotdog, Not Hotdog").
* Rails singularizes "criteria" as "criterium" and I didn't realize that was incorrect until it was kind of a lot of work to fix.
WHY I'M POSTING: I’d been dealing with burnout for a while, and getting this running has been incredibly rewarding. The majority of people in my personal life are non-technical so it's been hard to get reactions to it beyond "what is it?".
Would be thrilled with whatever honest feedback you have.", "url": "https://criteriabot.io/", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "49430207", "title": "Ask HN: What eval harness holds up in practice, and what is still missing?", "body": "There’s no shortage of eval frameworks, but once you move past simple single-turn prompt checks into multi-step, tool-calling agents, most of them start to feel either too heavy or too brittle for CI. Testing intermediate trajectories, retries, and non-deterministic state often turns into flaky LLM judges, slow test runs, or snapshot diffs that become painful to maintain.
For people evaluating production LLM apps or agents, what harness or setup has actually held up for you without creating more maintenance than it saves? Are you using a dedicated open-source/commercial framework, or did you eventually fall back to custom runners and curated golden sets? And what’s the biggest thing you still wish current eval tooling handled better?", "url": "https://news.ycombinator.com/item?id=49430207", "upvotes": 1, "comments": 1, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "46974783", "title": "Show HN: Auditi – open-source LLM tracing and evaluation platform", "body": "I've been building AI agents at work and the hardest part isn't the prompts or orchestration – it's answering "is this agent actually good?" in production.
Tracing tells you what happened. But I wanted to know how well it happened. So I built Auditi – it captures your LLM traces and spans and automatically evaluates them with LLM-as-a-judge + human annotation workflows.
Two lines to get started:
auditi.init(api_key="...")\n auditi.instrument() # monkey-patches OpenAI/Anthropic/Gemini\nThe interesting technical bit: the SDK monkey-patches client.chat.completions.create() at runtime (similar to how OpenTelemetry auto-instruments HTTP libraries). It wraps streaming responses with proxy iterators that accumulate content and extract usage from the final chunk – so even streamed responses get full cost tracking without the user doing anything.
What makes this different from just tracing:\n - Built-in evaluators – 7 managed LLM judges (hallucination, relevance, correctness, toxicity, etc.) run automatically on every trace\n - Span-level evaluation – scores each step in a multi-step agent, not just the final output\n - Human annotation queues – when you need ground truth, not just vibes\n - Dataset export – annotated traces export as JSONL/CSV/Parquet for fine-tuning
Self-host with docker compose up.
I'd love feedback from anyone running AI agents or LLMs in production. What metrics do you actually look at? How do you decide if an agent response is "good enough"?
GitHub: https://github.com/deduu/auditi", "url": "https://github.com/deduu/auditi", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "44805547", "title": "Show HN: AI Dev Assistant Framework – Add structure, rules and memory to LLM", "body": "After spending months working with Claude, Gemini, and others inside Cursor, I got tired of constantly fixing regressions and re-explaining my project’s logic. The AI was impressive — but blind without proper context.
I didn’t want more prompt tricks. I needed structure. So I built a framework that gives LLMs:
– codified project rules & constraints \n– a clear, step-by-step development protocol \n– a memory system that evolves over time \n– human-in-the-loop checkpoints to reduce failure
It completely changed how I use AI in real software projects. I’m sharing it open source in case others are trying to get more from their AI dev workflows too.
Happy to answer questions or go into technical details. \n→ Link above, feedback welcome!", "url": "https://github.com/Fr-e-d/ai-dev-assistant-framework", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "46541197", "title": "Show HN: Everdone CodeReview – AI code reviews as a trackable workflow", "body": "Hi HN,
We just launched CodeReview, the second service under Everdone, our work-as-a-service platform for engineering teams.
Our first service, CodeDoc, focused on helping teams understand large codebases by generating and keeping documentation updated.
With CodeReview, we’re tackling a different problem: code reviews that don’t stop at comments.
What CodeReview does\n- Reviews GitHub PRs or branches using AI\n- Flags issues across bugs, security, and performance\n- Assigns severity (high / medium / low)\n- Provides suggested fixes with explanations and example code
The key difference is that reviews become a shared, trackable workflow:\n- Issues live in a dashboard (not just PR comments)\n- Teams can assign owners and track status\n- Fixes can be re-reviewed\n- AI verifies whether issues are actually resolved
Think of it as lightweight issue tracking, but scoped purely to code review.
Some details\n- No setup, no agents, no pipelines\n- Unlimited team members\n- Public and private repos supported\n- Code is never used for model training\n- Usage-based pricing: first 200 files free, then $0.05 per file per review (early access)
We’ve also published live demos on popular open-source repos, so you can see real output without signing up.
This is still early, and we’re actively looking for feedback—especially around:\n- Signal vs noise in detected issues\n- PR-only vs broader branch reviews\n- How people want re-verification to behave
Link: https://everdone.ai
Happy to answer questions.", "url": "https://everdone.ai/", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "47248299", "title": "Show HN: AI Code Review CLI", "body": "This week we released the Kodus CLI.
It took a bit longer than we expected to ship. The reason was simple: there are already many ways to run reviews locally today. IDEs, extensions, terminal commands, agents inside the editor. So building “just another AI CLI” didn’t seem like a good idea.
The question that guided the project was different: how can we bring the quality of PR reviews to the moment when the code is still being written?
Today the CLI does two main things.
The first is running local reviews using the same context we use in PRs. The goal was to avoid that shallow review that only looks at the diff currently open in the editor. We try to reconstruct more repository context, similar to what happens during a PR review.
The second is helping resolve comments that Kody has already left on a PR, but directly from the local environment. Instead of opening the PR, reading the comment, going back to the editor, making the change, and repeating the process, you can work through those fixes directly in your coding workflow.
The whole idea revolves around reducing the feedback loop time.
Some design decisions came from things we heard from teams using other CLIs.
Auth in large teams often turns into friction.\nMany tools assume each developer will create an account before using the CLI. That becomes painful when someone just wants to try it, or when an entire team decides to experiment.
We introduced team keys. An admin generates the key and shares it with the team. Anyone who installs the CLI can start using it right away.
Rate limits can ruin the local experience.\nSome tools work well at first but become too restricted for continuous use.
The CLI runs BYOK by default, so you can use your own API key if you want.
Code agents are already part of the workflow.\nInstead of treating this as something separate, we built two layers.
The CLI works as a direct interface to our API.\nOn top of that, there are Skills that teach agents how to use the same review flow.
There’s still a lot to improve. Repo context, how suggestions are presented, integration with different developer workflows. We’re using it heavily internally and adjusting things as problems show up.
If anyone wants to try it or contribute:
- repo: https://github.com/kodustech/cli\n- feedback is very welcome\n- issues and PRs are too
If you usually run local reviews, I’d be curious to hear what actually works and what only sounds good in theory.", "url": "https://github.com/kodustech/cli", "upvotes": 5, "comments": 0, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "44801653", "title": "Show HN: GPT-reviewer – Simple AI code reviewer for GH Actions", "body": "GPT-Reviewer: AI-Powered Code Review GitHub Action
I've built a GitHub Action that automatically reviews pull requests using GPT-4o or Claude, enforcing custom project rules through inline comments.
Key Features:
• Custom rule enforcement via .project-rules.md configuration\n• Support for both OpenAI GPT-4o and Anthropic Claude\n• Gitignore-style file filtering with .ignore files\n• Inline PR comments with specific line-level feedback\n• Zero-config setup beyond adding your API key, rules file and ignore file (optional)
How it works: The action fetches PR diffs, parses only added lines, and sends them to your chosen AI provider along with your project rules. The AI returns structured JSON feedback that gets posted as inline comments on the specific lines that need attention. It is a one-shot prompt.
Example project rules:
## Security\n- Never hardcode API keys or secrets\n- Validate all user inputs
## Code Style\n- Use descriptive variable names (whatever that means)\n- Mark typos as warnings
Setup is straightforward:
1. Add .project-rules.md with your coding standards\n2. Create a GitHub workflow that runs on PR events\n3. Add your AI provider API key to repository secrets
The action only reviews new code additions, keeping noise low while ensuring consistency across your codebase. It's particularly useful for teams wanting to automate enforcement of coding standards and security practices.
Built with Python, uses the GitHub API for PR integration and unidiff for parsing changes. The AI providers are abstracted, making it easy to switch between OpenAI and Anthropic or add new providers.
GitHub: https://github.com/vayqerlukashakkarainen/gpt-reviewer
Would love feedback from teams already using AI in their development workflows, or anything really. I personally like "one task" AI applications, which does only what it is told to do. I am really into researching AI uses at the moment.
Kinda funny note:\nI generated most of this post using OpenCode, which is an CLI agent to code and vibe with. But it seems it can be used to generate great summaries of the project as well :)", "url": "https://github.com/vayqerlukashakkarainen/gpt-reviewer", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "47035076", "title": "AI-powered Git CLI that generates commit messages automatically", "body": "I got tired of context-switching to write commit messages and PR descriptions,\nso I built gut – a CLI that uses AI to handle the boring parts of git workflows.
Examples:\n gut commit → generates commit message from staged diff\n gut pr → generates PR title and description\n gut review → AI code review of your changes\n gut find "login bug" → finds commits by vague description\n gut stash → stash with auto-generated name
It focuses only on git operations, so responses come back in seconds.\nBYOK (Gemini, OpenAI, or Anthropic). Keys stored in system keychain.
Customizable via .gut/ templates per project.
GitHub: https://github.com/user/gut\nnpm: npm install -g gut-cli", "url": "https://news.ycombinator.com/item?id=47035076", "upvotes": 1, "comments": 1, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "38100665", "title": "Show HN: Freeplay – Testing and Evaluation for LLM-powered features", "body": "Hi HN,
We're excited to announce the public beta of Freeplay, an end-to-end platform for companies to build, testing and evaluate LLM-powered features. Built for engineering & product teams to prototype efficiently, test effectively, and optimize the products you build for your customers.
Key Features
- Prompt & Model Management: Create, test, and deploy prompts and model configuration without code changes, just like other server-side experimentation tools.
- Live Monitoring: Track and analyze every LLM interaction across your environments. Save real-world test cases for later use as you iterate.
- Automated Testing & Evaluations: Define custom evaluations that matter for your customers. Run and compare batch test cases easily from within your code. Use our human labeling workflow and AI assisted auto-evaluations to drive better customer outcomes & create a better feedback loop.
- Developer SDK & Web Dashboard: We offer Node, Python, and Java SDKs. Developers can collaborate with PMs, designers & others in web dashboard.
In a world where LLMs increasingly play a role in the last mile of the customer experience, Freeplay is here to help teams ensure the products you build consistently deliver for your customers.
Learn more from our developer docs here: https://docs.freeplay.ai/docs
We're eager for feedback as we continue to build & refine Freeplay. Thanks!", "url": "https://freeplay.ai/", "upvotes": 3, "comments": 0, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "43164465", "title": "Show HN: open source framework for building nanoservices", "body": "Hey HN,\nWe’re the team behind Deskree, and we just open-sourced Nanoservice TS (https://github.com/Deskree/nanoservice-ts), a TypeScript framework for building single-responsibility containerized services—aka nanoservices. Basically, if you know the pain of working with microservices, this one is for you.
A couple of years ago, we started Deskree as a BaaS product. Eventually, our tiny team of three engineers was managing 20,000 microservices. And as you might know, microservices at that scale suck to manage. Every change meant updating dozens of repos, rolling out updates across services felt like herding cats, and when something broke, it took forever to figure out where.
At some point, we figured we can create small reusable nodes, each handling just one task. No need to rewrite the same logic across multiple services, updating a node propagates changes everywhere it’s used. Add built-in monitoring and observability, trace things on a code-level and then debugging gets so much easier.
Turns out, this concept already existed. Apple and IBM have been using nanoservices internally for years, but somehow, no one ever released an actual framework for it. So, we built one.
Each nanoservice is just a function running in an isolated container. Built-in protocol for inter-service communication gives low latency, and you can run this with Docker, Kubernetes, Serverless, or anything really. Deploy as monolith or microservices, and then change it up if you need to. Built-in monitoring and observability also makes debugging easy.\nAdding Python library soon for AI/ML workflows.
To get started:
npx create-nanoservice my-service
Check it out, would love to know what’s broken, what’s missing and what would make it better:
GitHub repo: https://github.com/deskree-inc/nanoservice-ts
Docs: https://nanoservice.xyz/docs/d/introduction/welcome
Website: https://deskree.com
X: https://x.com/nanoservice_ts
Excited to share this with everyone here, let us know your thoughts!", "url": "https://news.ycombinator.com/item?id=43164465", "upvotes": 4, "comments": 0, "sub": "hackernews", "signal": 5.2, "hits": [] }, { "src": "hackernews", "id": "48322744", "title": "Show HN: TheFoundry – Easy bootstrapping framework for MultiAgent Systems", "body": "For months, I struggled to build complex, long-running projects using AI agents and I kept failing... One shots, refactoring, high token consume...
After several refinements, I built a framework that is actually working for me and I believe is easy for "humans". It follows Enterprise engineering principles to AI, and now my productive agentic sessions are lasting ~25% longer before depleting my tokens.
The architecture relies on 3 rules:
- Pull-Based Workflow: Agents read a Markdown Kanban board (team_status.md) and pull tickets instead of being pushed tasks.
- Anti-Loop Budgets: Agents have a hard stop after 5 failed iterations to prevent token exhaustion.
- TOML for A2A: Agent-to-agent requests use TOML to eliminate hallucinated JSON syntax errors.
I know agentic bootstrapping can be complex for non-technicals, so I designed this for zero-friction setup. You don't configure anything manually, ust paste this into your favorite IDE (Cursor, Claude, Antigravity):
"Deploy the bootstrap of the project from here https://github.com/aavilagallego/TheFoundry and let's start working."
An ephemeral @bootstrapper agent will autonomously clone the repo, hydrate the global constitution (AGENTS.md), and then permanently delete its own source code to keep your repo clean.
I’ll keep evolving the rules, but this system is yielding great results today. Happy to help and I’d love to hear your thoughts to improve the system!", "url": "https://github.com/aavilagallego/TheFoundry", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 5.1, "hits": [] }, { "src": "hackernews", "id": "47150394", "title": "Show HN: LedgerMind – true zero-touch autonomous memory for AI agents", "body": "LedgerMind is a zero-touch memory system for AI agents that works using client-side hooks.
No manual tool calls. \nNo "remember this" prompts. \nNo extra setup.
It automatically:\n• Searches and injects relevant memories before every prompt\n• Logs every agent action and tool result (file reads, script executions, etc.)\n• Self-heals every 5 minutes\n• Keeps full Git-based audit trail\n• Resolves memory conflicts autonomously
Currently 100% stable and working out-of-the-box with Gemini CLI. \nSupport for Claude Desktop and Cursor coming very soon.
Project: https://github.com/sl4m3/ledgermind
Would love feedback from people building long-running autonomous agents.", "url": "https://github.com/sl4m3/ledgermind", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 5.1, "hits": [] }, { "src": "hackernews", "id": "45451314", "title": "Show HN: Mdchat – Markdown-first terminal / CLI tool for LLM collaboration", "body": "TL;DR\nmdchat lets you chat with LLMs directly with your Markdown files on your terminal. You can ask, edit, summarize, and generate inline without leaving your text workflow.
What is mdchat?\nmdchat is a cli tool that lets you collaborate with LLMs directly to write markdown files. You can issue prompts, generate content, edit, summarize — all inline, in your Markdown files via terminal sessions. The idea is to bring LLM interaction into your writing workflow!
Motivation:\nI write a bunch of markdown files for taking notes, summarizing bunch of notes that I have written, editing, etc and most of the time, I interact with ChatGPT to make it better~ since back and forth was getting to me a bit, I thought it would be great to have this!
Future Roadmap:\n1. Conversation memory\n2. Smarter API usage\n3. Better reasoning for Markdown content\n4.Context management across multiple files
Feedback and contributions are welcome!", "url": "https://www.npmjs.com/package/mdchat", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 5.1, "hits": [] }, { "src": "hackernews", "id": "48994848", "title": "Show HN: WorldBuild Bench repo: testing LLM world coherence with 3D games", "body": "I built WorldBuild Bench because, as we all know, llm bench scores often say something very different from what models actually feel like to use. It's really dependent on the type of tasks.
I personally want to test spatial, temporal, and causal coherence in an interactive 3D world. Does the model understand where things are, world stays consistent over time and do the consequences make sense?\nThere is a million people generating random games here and there on yt, but I want something that I can reproduce every time a model comes out and gets scored.
For this first run, 9 models received the same three roughly 30-line game prompt. I just added Kimi k3 to the results.
They all ran in high-thinking mode through the same open source harness, with the same sub-agent setup and access to Three.js, Rapier, and Playwright. There is currently one run per model per brief, producing 27 browser-playable games.
Because the qualities I’m interested in are difficult to score automatically, the main evaluation happens through blind pairwise comparisons. You play two games built from the same brief without seeing the model names, then compare their game feel, world design, presentation, completeness, and overall quality.
I’m also publishing the prompts, generated artifacts, generation time, estimated cost, and code size.
Fable produced some of the strongest games from what I could see, but its three runs cost about $756. GPT-5.6 Sol cost about $108, while GLM-5.2 and Grok 4.5 each cost around $19. Opus also felt closer to Fable than I expected, considering the large cost difference.\nKimi somehow ended up roughly at the cost of GPT, but performed somewhat similar to Opus (thats just my subjective opinion there)
This first run is small, and as stated above, human preference is subjective. But I plan on running more and hope to evolve the methodology. As long as I can afford all these tokens. Fable is ridiculously expensive.
If you look at it, I'd really appreciate criticism of the task methodology, design, blind evaluation, etc. What would make this rigorous enough to be truly useful.", "url": "https://github.com/sebnado/worldbuild-bench", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 5.1, "hits": [] }, { "src": "hackernews", "id": "43760162", "title": "Show HN: CreateMVP.app – First open-source tool to generate MVP specs for LLMs", "body": "What the Platform Delivers:
AI Plan Generator – Accepts a short requirements brief or a PDF; outputs a complete implementation bundle (technical spec, architecture, user‑flow diagram links, task breakdown, and a polished PRD).
Multimodel Chat Console – One pane to converse with GPT‑4o, Claude 3, Gemini 1.5 Flash and other public as well as open source large models, keys stay local.
AI Tool Comparison Hub – Curated cards for 100 + dev‑centric AI tools to accelerate due‑diligence.
MCP Servers & Rule Packs – One‑click copies of community‑maintained server endpoints plus Cursor & Windsurf rules to supercharge IDE workflows.
Open‑source PRD Creator – Apache‑licensed codebase; self‑host or fork without restrictions.", "url": "https://createmvps.app/", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 5.1, "hits": [] }, { "src": "hackernews", "id": "44504870", "title": "Show HN: Visual Editor for Cursor", "body": "Hi!
We noticed that our users extensively use Shuffle (a visual editor for developers) in conjunction with Cursor. That's why we built the Shuffle CLI, a lightweight tool that creates a seamless bridge between Shuffle and Cursor.
With this CLI, you can:
* Sync your visual components from Shuffle directly into Cursor projects
* Automatically generate clean, editable code from your designs
* Keep your design and dev workflows tightly integrated without copy-pasting or re-exporting
We built this to reduce the friction between prototyping and production. If you're using Cursor as your IDE and Shuffle for layout and styling, this tool may be a good fit for you.
Here's how to test it quickly:
mkdir website
cd website
npx @shuffle-dev/cli get example-project .shuffle --rules=cursor
The project will be saved in the .shuffle directory so you can, for example, ask Cursor:
"Create a next.js app from the .shuffle directory"
In a real project, you can modify it in Shuffle and sync it after changes:
npx @shuffle-dev/cli sync <project_id>
And ask Cursor again: "Add new pages from .shuffle to my next.js app"
We haven't used MCP yet. We've tested it, but the CLI is better at maintaining consistency in format.", "url": "https://shuffle.dev/cursor", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 5.1, "hits": [] }, { "src": "hackernews", "id": "43762499", "title": "Show HN: I made an open source Idea to App WebApp", "body": "Create MVPs with AI in seconds.
A comprehensive guide to building Minimum Viable Products using the latest AI tools and technologies. Generate complete implementation plans in minutes.
Comes with multiple add-ons:\n FREE Tools for EVERYONE: Yes, completely free for all users!
AI Chat: Brainstorm, refine ideas, and get instant feedback by chatting directly with powerful AI models like Gemini 1.5 Flash & OpenAI (more coming!). Preserve context across sessions!
AI Tool Comparison: Stop hunting through dozens of tabs! Compare features, pricing, and use cases of leading AI development tools side-by-side to make informed decisions for your stack.
MCP & Rules Library: Access our curated collection of MCP (Meta Cognetic Programming) servers and rules (like Cursor and Windsurf integrations) to dramatically improve your AI development workflow.", "url": "https://github.com/rohitg00/CreateMVP", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 5.1, "hits": [] }, { "src": "hackernews", "id": "44815727", "title": "Show HN: Framework to structure LLM dev workflows with Markdown-based protocol", "body": "I use Claude, Gemini and Kimi daily in Cursor to build real software. But I kept hitting the same limits:
– The AI forgets everything between steps
– Architectural decisions get lost
– Same regressions, over and over
So I stopped trying to write better prompts, and started building structure.
The result is a lightweight, markdown-based framework that turns your LLM into a reliable, context-aware assistant. It includes:
– A codified rule system (project constraints, architecture, best practices)
– A development workflow from PRD to retrospectives
– Memory that evolves over time
– Human-in-the-loop validation at each step
It’s completely open source and model-agnostic. I use it daily, and it changed how I collaborate with AI.
Happy to share use cases or technical details. Feedback very welcome.", "url": "https://github.com/Fr-e-d/ai-dev-assistant-framework", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 5.1, "hits": [] }, { "src": "hackernews", "id": "45959846", "title": "My tiny workflow for an AI code review assist", "body": "I wanted to share a small workflow I find helpful that I haven't necessarily seen mentioned elsewhere. I don't always want AI assistance for a code review but it can sometimes be helpful and for those cases I use the below method.
1. Download the raw PR diff file. In GitHub you can do this very easily by adding '.diff' to the end of the pull request url and then saving the resulting page.
2. Go to your preferred AI chat/ide that accepts file attachments and has access to your codebase, I like Cursor for this.
3. Git checkout the feature branch if you aren't on it already.
4. In the AI chat attach the diff file and a message like "help me review this pr, diff attached, we are on the feature branch"
That's it. Sometimes I make the chat message more relevant, tell it some background about the task, and ask it for specific parts of the pull I am interested in checking, but nine times out of ten I just use the very simple message as above and it works fine.
It certainly spouts out some garbage, but it has also caught some very obvious and non-obvious bugs.
What I like about this method as opposed to say bugbot, apart from the fact that bugbot costs extra, is it makes it easy to continue the conversation and also to look through the files/diffs in the ide.
Hope this workflow is helpful to someone.", "url": "https://news.ycombinator.com/item?id=45959846", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 5.1, "hits": [] }, { "src": "hackernews", "id": "43872568", "title": "Show HN: AI code review now available on Azure DevOps", "body": "Hey everyone,
Just wanted to share a quick update we just launched at Kodus.
For those who don’t know it yet, Kodus is a code review agent that runs directly in your team’s Git workflow (GitHub, GitLab, Bitbucket… and now Azure DevOps as well). It helps maintain code quality and consistency by analyzing each PR based on your team’s own rules and repository standards.
Support for Azure had been a common request — so if your team uses it, you can now plug Kodus right into your workflow and give it a try.
Docs: https://docs.kodus.io/how_to_use/en/overview\nRepo: https://github.com/kodustech/kodus-ai
We’re constantly improving the tool, so any feedback, suggestions, or criticism would be super helpful!", "url": "https://kodus.io/en/", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 5.1, "hits": [] }, { "src": "hackernews", "id": "41757003", "title": "Show HN: CREV – A Go-based CLI tool for AI code reviews and codebase exports", "body": "I’ve recently built CREV, a Go-based CLI tool designed to get AI-powered code reviews from your terminal. The idea came from my frustration with manually copying code into ChatGPT or Claude to get feedback on my projects. Although ChatGPT could provide me with useful suggestions, it lacked the full context of my project, which often resulted in incomplete reviews since it didn’t know my entire directory structure and the content of all the files. I wanted to fix that, while also eliminating the constant switching between VSCode and my browser.
So after a month of development, I’m excited to share CREV:
- GitHub: https://github.com/vossenwout/crev
- Website: https://crevcli.com/
Features:
- Full Codebase Export: Exports your entire directory structure and the content of all the files of your project into a single text file.
- AI-Powered Code Reviews: CREV reviews your bundled codebase and outputs the review as a markdown file.
- Terminal-Based Workflow: CREV is a CLI tool, removing the need to switch between your editor and the browser.
I have written the CREV CLI tool in Go as I was interested in learning the language and I heard many good things about its efficiency and speed. I used Cobra https://github.com/spf13/cobra to manage the CLI commands and Viper https://github.com/spf13/viper for handling configurations. This is the first project I have done with Go but I find the language interesting and the Go routines also help with reading in your entire codebase. For the code reviews themselves I use google cloud functions which invoke GPT-4o (am also planning to add Claude 3.5 and GPT-o1).
I’d love to hear your feedback—whether it’s ideas for new features or reasons why you believe this tool is useful or useless to you. I am using it daily so it at least solved my own problem :)", "url": "https://news.ycombinator.com/item?id=41757003", "upvotes": 2, "comments": 0, "sub": "hackernews", "signal": 5.1, "hits": [] }, { "src": "github", "id": "1349546686", "title": "AlbusChen/GameForge-Harness", "body": "Open execution and independent verification for game-development agents across engines. ai-agents benchmark evaluation game-development godot harness llm unity", "url": "https://github.com/AlbusChen/GameForge-Harness", "upvotes": 2, "comments": 0, "sub": "github", "signal": 5.1, "hits": [ "benchmark" ] }, { "src": "stackoverflow", "id": "78333793", "title": "Restrict responses from a language model (LLM) to only information available in a specific document", "body": "prompt large-language-model retrieval-augmented-generation", "url": "https://stackoverflow.com/questions/78333793/restrict-responses-from-a-language-model-llm-to-only-information-available-in", "upvotes": 2, "comments": 0, "sub": "stackoverflow", "signal": 5.1, "hits": [ "retrieval" ] }, { "src": "hackernews", "id": "44345623", "title": "Show HN: I released a OS remote agent callable from mobile", "body": "Hey HN! I'm Emanuele (EmaDev01 on X), creator of FixO Dev, an open-source agent designed to instantly transform issues into high-quality pull requests. Today, I'm excited to officially launch it here!
FixO Dev is perfect for quickly resolving small issues directly from GitHub, whether you're on your desktop, using your phone, or simply don't have your usual development environment available. Just mention @fixodev in any GitHub issue or PR comment, and watch it immediately generate professional-grade code fixes as pull requests. Check out the demo: https://youtu.be/NgGN2d2ZJLs
As a developer, I often found myself needing quick, agile solutions for repetitive code improvements, especially when away from my main setup or working on-the-go. FixO Dev addresses this by delivering instant, secure, and effortless AI-driven fixes without leaving GitHub.
With FixO Dev, you can:\n- Quickly resolve code issues directly from GitHub or even via mobile.\n- Trigger fixes simply by mentioning @fixodev.\n- Effortlessly handle multiple languages including JavaScript, TypeScript, Python, and more.\n- Rely on secure, isolated Docker-based execution without data retention.\n- Seamlessly integrate into open-source or enterprise workflows.
Early users are leveraging FixO Dev to:\n- Swiftly automate small yet tedious code fixes.\n- Maintain high-quality, consistent codebases on-the-fly.
Collaborate efficiently and reduce review overhead.
I'm actively seeking feedback, community contributions, stars, and collaborations. Early adopters interested in private repository support are especially welcome.
I'd love your thoughts—what small but repetitive coding tasks do you wish to solve instantly? Any ideas or feedback are highly appreciated!", "url": "https://github.com/epavanello/fixodev", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "45334395", "title": "Show HN: Arkain – AI-powered Cloud IDE for building real apps from your words", "body": "Hi everyone, Arkain team here.
Today we're launching the beta of Arkain, an AI-powered Cloud IDE.
We wanted to share what we've built and get honest feedback from the community.
---
1. The Problem We're Solving
How many times have you found yourself setting up the same boilerplate for a new project? Great ideas often take weeks to get off the ground – not because of complexity in the core logic, but because of environment setup. React frontend configuration, Express backend scaffolding, database schema design, deployment pipelines... by the time you're done with setup, momentum is lost.
Team development amplifies these issues. Different local environments, version conflicts, and dependency management create friction that keeps developers from focusing on what actually matters. We've all been there – spending more time debugging environment issues than building features.
2. Our Approach
Our goal is simple: eliminate the productivity barriers that slow down development.
Arkain is a web-based IDE that lets you configure development environments with a few clicks and generate complete applications from natural language descriptions. We want developers to spend their time on ideation, feature design, and user experience rather than repetitive setup tasks.
3. Key Features
- End-to-end app generation from natural language: Unlike existing AI coding tools that focus on code snippets or frontend-only generation, Arkain creates complete, deployable applications.
- Context-aware AI agent: The AI maintains project context, so you don't need to re-explain your architecture with every request.
- Security-first cloud infrastructure: Built on Zero Client architecture with SBOM and containerization for both security and performance.
- Template community: Share and discover proven solutions to accelerate development.
4. Current Limitations
Being in beta, we have several areas that need work:
- Complex business logic still requires manual refinement
- Some framework combinations aren't fully optimized
- Performance tuning needed for large-scale projects
5. What We'd Love Feedback On
- Which types of projects would benefit most from this approach?
- What friction points do you see with existing development workflows?
- For enterprise adoption – what are your security/governance concerns?
6. Community-Driven Development
We're committed to growing this with the community. We want to be transparent about what we learn and build, and we'll be open-sourcing our most useful templates progressively. We're planning to start with RAG-based AI chatbot and feedback dashboard templates.
If you have any questions, ideas, or suggestions for improvement, please don't hesitate to reach out. We'd especially appreciate hearing about any development workflow challenges you're facing in your day-to-day work.
Looking forward to your thoughts and experiences in the comments.
You can try Arkain free here: https://arkn.ai/qH22w", "url": "https://arkn.ai/qH22w", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "46395140", "title": "Show HN: Chaos engineering for LLMs – Making models cross-examine each other", "body": "Single-model inference is a single point of failure. I got sick of Chatgpt hallucinating fake citations and having to manually check them in a different tab with Claude.
So I built Council
The Difference: Shared Context Most "multi-bot" UIs are just parallel silos. Council uses a sequential backend stream where every response is injected into the context of the next model.
If GPT cites a fake study, Claude sees it and calls it out.
If Gemini misses a logic gap, Grok roasts it.
Adversarial Logic Instead of "consensus" (which leads to boring, average answers), I'm using model-on-model friction to surface the truth. By forcing GPT-4o, Claude 3.5, Gemini 1.5, and Grok into one adversarial window, you get a "red-teamed" output that’s harder to fake.
What I need: It's an MVP. I'm trying to figure out if "Inter-model Cross-Examination" actually kills hallucinations or just creates more expensive ones.
Give it a spin and try to break the logic. No fluff, just testing the architecture.", "url": "https://www.usecouncil.app/", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "47340497", "title": "Rate my privacy-first AI ad architecture (patent pending)", "body": "I'm building SejalVault, a patent-pending framework for advertising inside AI responses that tracks nothing – no cookies, no profiles, no behavioral history. Just the prompt.
Here's the architecture:
1. Prompt arrives at AI interface (mobile, desktop, assistant).\n2. AI parses intent in real-time using protected classification logic.\n3. If commercial intent detected (e.g., "best noise-canceling headphones"), it queries a local index of certified brand listings.\n4. Matching uses only prompt context + brand trust score. No user data.\n5. Ad formats: sponsored summaries, buy-now cards, verified listings – inserted naturally into the response.\n6. Short-Tempered Memory™: a local encrypted buffer stores last 2-3 prompts for up to 72 hours to simulate continuity. Never synced, auto-deletes on topic change or timeout.\n7. Repetition Control: host apps set limits on ad frequency per prompt category (e.g., 1 ad per 48h). Privacy mode blocks repeats entirely.\n8. Certification: brands must verify domain/identity to access premium formats. Non-certified get text-only links.\n9. All decisions AI-governed – no forced placements, no system hooks, no tracking.
Patent filed July 2025 (covers prompt-based matching, ephemeral memory, certificate-gated access, etc.).
Questions:
1. Does this architecture hold up technically? Any gaps?\n2. Would you trust it as a user? As a developer?\n3. What's the hardest part to implement correctly?\n4. Any concerns about the Short-Tempered Memory approach?
I'm here to answer questions and learn from your feedback. Thanks!", "url": "https://news.ycombinator.com/item?id=47340497", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "47255561", "title": "Show HN: Residuum | Agentic AI with continuous context", "body": "After poking around in the various ‘claw’ spaces, I realized two things. One the foundation of OpenClaw is genius, and two, everyone is innovating in the wrong directions.
Because, the system prompt and memory just being a bunch of markdown files is very very smart. At any time you can go see why the agent is acting a certain way, and change it, with nothing but a text editor. Heartbeats are also a genuinely solid way to handle proactivity.
Yet the ecosystem that spawned around it is either chasing absolute minimalism or endless feature expansions. Meanwhile the communities around these tools are constantly trying to figure out how to get their agent to remember anything.
I didn’t find anyone else really trying to solve that problem so I decided to take a crack at it. The idea for "Observational Memory" came from this post from Mastra https://mastra.ai/blog/observational-memory timestamped observations that get continuously compressed. I added episodes and projects on top of it as a way to give the agent an index of what it knows instead of having to search blindly.
Most everything else is a ‘me too!’ implementation with my own spin/improvements. I’m really proud of how it’s turned out so far and wanted to share. Open to contributions if it sparks your interest!
Also, it's Rust btw ;) (Not for any real reason, I just fucking hate python/typescript)", "url": "https://github.com/Grizzly-Endeavors/residuum", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "43026575", "title": "Ask HN: What are you running for .windsurfrules?", "body": "Adding the following .windsurfrules file has saved me alot of frustration and time. I'm interested to hear what other Windsurf users are running:
Use uv for package management instead of pip.\n When tests pass, and there are significant changes to the codebase, commit changes to git.\n Save each user prompt to a file in the prompts directory.\n\nWhat is Windsurf? It's a code assistant similar to Cursor and Devin, available as a VSCode fork for a monthly fee. More info (and a couple of prompts): https://github.com/ichoosetoaccept/awesome-windsurf", "url": "https://news.ycombinator.com/item?id=43026575", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "47270193", "title": "Show HN: Aidevshield NPM audit for AI coding tool workflows", "body": "I built aidevshield, a free open-source security scanner that catches vulnerabilities in AI coding tool configurations things like Cursor, Copilot, and Cline setups.
The problem: AI coding assistants are becoming attack surfaces. In the past year we've seen real exploits:
Clinejection (Dec 2025): Prompt injection via GitHub issue titles → AI triage bot executes shell commands → malicious npm package published to 5M users\ntj-actions/changed-files (Mar 2025): Tag repointing attack hit 23,000 repos via pull_request_target\nShai-Hulud (2025): First self-propagating npm worm using postinstall hooks\nRules File Backdoor (Feb 2025): Hidden Unicode characters in .cursorrules for invisible prompt injection\nExisting tools cover parts of this — Zizmor and actionlint for GitHub Actions, Socket.dev for npm — but nothing scans across all four domains: workflows + AI configs + npm packages + prompt injection.
aidevshield does. One command, zero dependencies beyond js-yaml, fully offline:
npx aidevshield scan .\nWhat it detects:
Dangerous GitHub Actions patterns (wildcard users, untrusted event field interpolation, unpinned third-party actions)\npull_request_target with untrusted checkout (Pwn Request pattern)\nMalicious npm lifecycle scripts (postinstall curl | sh, node -e inline exec)\nHidden Unicode in AI config files (.cursorrules, .github/copilot-instructions.md)\nWildcard tool permissions (Bash(), Edit())\nExposed .env files without .gitignore protection\nCache poisoning + credential exposure combos\nOutputs text, JSON, or SARIF (for GitHub Code Scanning integration).
56 end-to-end tests. Every detection maps to a documented real-world attack.
MIT licensed. No signup, no paywall.
GitHub: https://github.com/aidevshield/aidevshield
Happy to answer questions about the threat landscape or implementation.", "url": "https://github.com/aidevshield/aidevshield", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "45765778", "title": "Show HN: AI Resource Manager", "body": "AI Resource Manager (V3) (FKA AI Rules Manager)
A package manager for AI rules and prompts with semantic versioning and automatic distribution to AI tools.
What is ARM?
ARM is a package manager for AI resources, designed to treat rulesets and promptsets as code dependencies. It introduces semantic versioning, reproducible installs, and straightforward distribution to your AI tools.
Seamlessly connect to Git repositories such as awesome-cursorrules or your team's private collections. Install and manage versioned resources across projects, and keep everything in sync with your source of truth.
Why ARM?
Managing rules and prompts for AI coding assistants like Cursor or Amazon Q is cumbersome:
- Manual duplication: Copying resources disconnects them from updates and the original source
- Hidden breaking changes: Updates may unexpectedly alter your AI's behavior
- Poor scalability: Coordinating resources across multiple projects becomes chaotic
- Incompatible formats: Frequent manual conversions between different tool formats.
ARM solves these problems with a modern package manager approach.
Key Features of ARM
- Consistent, versioned installs using semantic versioning (except for git based registry without semver tags, which gets a little funky)
- Reliable, reproducible environments through manifest and lock files (similar to npm's package.json and package-lock.json)
- Unified resource definitions that compile to formats needed by any AI tool (the audacity! clutches pearls)
- Priority-based rule composition for layering multiple rulesets with clear conflict resolution (your team's standards > internet best practices)
- Flexible registry support for managing resources from Git, GitLab, and Cloudsmith
- Automated update workflow: easily check for updates and apply them across projects (nice)", "url": "https://github.com/jomadu/ai-resource-manager", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "47159700", "title": "Show HN: Deff – Review AI-generated code changes", "body": "I built Deff because AI coding tools sped up writing code, but reviewing their changes became the new bottleneck. \nMost of my time was going into checking noisy diffs, understanding intent, and making sure nothing subtle broke.\nDeff is focused on one thing: helping you review AI-generated code changes faster and with more confidence. \nIt helps surface what changed and is allowing me to use it with some vim motions so I can easily jump from nvim to opencode to deff.\nWould love feedback from people using AI coding assistants heavily — especially on review workflows, false positives, and what still feels slow.", "url": "https://github.com/flamestro/deff", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "41878692", "title": "Show HN: Shell script for AI-powered code reviews using local LLMs", "body": "Here is a shell script that performs automated code reviews using locally hosted Large Language Models (LLMs). This tool to address the need for privacy-conscious, customizable, and efficient code review processes.
Key features:\n- Uses locally hosted LLMs (compatible with models like GPT-J, BLOOM, etc.)\n- Analyzes pull requests and provides detailed feedback\n- Customizable review criteria and output format\n- Language-agnostic (works with multiple programming languages)\n- Fast execution, suitable for CI/CD pipelines
The script is designed to be easily integrated into existing workflows and can be customized based on team preferences and project requirements.", "url": "https://gist.github.com/alwin-augustin-dev/c1caaa30361f7ee320fb9cb957b3b0e9", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "46976128", "title": "Show HN: Monitor, audit & alert on AI agent actions and interactions", "body": "Monitor, visualize, audit, and alert on AI agent actions and interactions with PingPulse
We built PingPulse because debugging AI agents in production is painful.
As a DevOps Engineer, I have literally faced this problem of tracking what stage is the ML training is in by scrolling the logs forever to find out that the process has terminated few seconds after the start due to race-condition. I have wasted hours waiting for the process to complete while also wasting the compute costs of provisioned huge machines.
Logs tell you what happened, but not always how the agent behaved step-by-step. When agents retry, branch, call tools, or make decisions across stages, it becomes hard to trace unexpected behavior.
PingPulse works by letting you instrument your agent with a simple key and send structured “pings” at each stage. We turn those into:\n- A stage-by-stage execution timeline\n- An audit trail of agent actions\n- Alerts for deviations (retries, delays, out-of-order steps, prohibited interactions)
We launched on Product Hunt yesterday.\nThe goal is to make agent behavior visible and predictable in production environments.
Getting started is simple: \n1. Give your key to your Agent \n2. Share a doc with your AI Agent \n3. See how the workflow is created, visualized, audited, and has alerting options too.
Would love feedback — especially from teams running multi-step AI workflows.", "url": "https://pingpulsehq.com", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "46700164", "title": "Show HN: Autonomous outbound research and outreach drafts", "body": "Sales teams don’t have a “lead problem.” They have a time problem.
SDRs spend hours researching. Then they send generic outreach that gets ignored.
Prospecter removes that prospecting trap.
It’s an AI SDR workflow:
create a campaign for a segment
paste a target URL
get qualified leads, fit scoring, and pain-based outreach drafts ready to review and send
We’re in private beta with pilot teams and tightening the product based on results.
If you’ve built or run outbound, I’d value blunt feedback on:
how you define “qualified” and what signals you’d score
what would make you trust automated research plus draft outreach
what you’d need to ship this safely to a team", "url": "https://www.prospecter.io", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "42360841", "title": "Show HN: KitchenAI Open Source LLMops development kit. Notebook to server", "body": "Over the last year of building AI enabled SaaS applications I became increasingly frustrated at the developer experience of going from AI RAG cookbooks authored in jupyter notebooks to integrating it into my application. Notebooks are great and all but it's incredibly hard to test which part of it was actually important for my app. This led me down the road of having to understand every piece of code in each notebook, deciphering what was important, somehow build an API server as a POC to then hook it into my app. The feedback loop was excruciatingly long, painful, and most of the time I canned the POC because it wasn't quite what I wanted.
this is when it dawned on me that the roles in the AI developer world are fractured into two. Data Scientists and AI devs want easy notebooks to test methods and techniques but do not care to ship something that can be easily be consumed by applications.
In the other camp lies application devs, they just want simple API's that they can use to test quickly and verify these AI methods enhance their application.
Enter KitchenAI.
A way to bridge the gap between the two by converting AI related Jupyter notebooks into a ready made production API server so that it becomes easy to test various cookbooks, recipes, and techniques. Shortening the development cycle in half while giving users a complete local experience with the ability to share them as docker containers.
Completely vendor agnostic and framework agnostic, the goal is to give developers the most about of freedom to use the libraries they already feel most comfortable using.
It comes with a plugin architecture so I envision our team and the community building all sorts of llmops type plugins like evaluation frameworks, observability, prompt management and more.
A lot of hard work was put to provide something that is totally open source, local, and with battle tested technology like Django so that developers didn't have to rely on 3rd party providers.
We’ve launched this repo under Apache license so any developer can use the tool. We're working hard to provide a managed cloud version with much deeper integrations, metrics, analytics, and workflows for those that want have more complex demands
Give it a spin: https://github.com/epuerta9/kitchenai. Let us know what you think!", "url": "https://github.com/epuerta9/kitchenai", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "hackernews", "id": "39273121", "title": "Ask HN: CI/CD and Hosting for GPU-Based ML Demos", "body": "I was wondering what is HN's take on the state of the art when it comes to hosting GPU-based Machine Learning model demos. We are a university unit with a strong focus on Applied ML and the need to host research applications and student project applications that rely in GPU-based models.
We currently focus on the automation of the CI/CD of these demo applications and prototypes that are based on computer vision models or LLMS. We are aware of solutions that cover the pipeline aspect of CI/CD such as Gitlab, Github and the ML OPS platforms.
Where it currently breaks down for us, is the identification of hosting that would allow us to deploy a range of demo or prototype applications.
Our requirements are:
- host a number of applications / demos at the same time
- only prediction is of interest here (training happens on other machines)
- in many cases there is the need to host our own trained models
- GPU in the range of 12-24 GB GPU
- traffic would be minimal
- minimum redundancy or fault-tolerance levels
- would like to keep expense at level of 500-1000$ per month
The hosting platforms we are currently evaluating are:
- https://www.centron.de/en/centron-cloud-gpu-services/ \n- https://www.ovhcloud.com/en/public-cloud/prices/
To use these platforms to host multiple demos would it be the easiest to run Kubernetes and deploy Pods?\nAre there good best practices to host multiple low traffic web applications based on this setup?\nOr maybe there exists a much simpler setup to share a GPU between applications.
Thanks a lot in advance for your input. This will directly flow into the hosting implementation but will also find its way into the teaching after review.", "url": "https://news.ycombinator.com/item?id=39273121", "upvotes": 1, "comments": 0, "sub": "hackernews", "signal": 5.0, "hits": [] }, { "src": "github", "id": "1318968799", "title": "api-evangelist/poolside", "body": "poolside — independent third-party profile of a public API surface, by API Evangelist. poolside builds open-weight foundation models and the systems that refine them for agentic software engineering. Its Laguna model family (Laguna XS 2.1, a 33B on-device model, and Laguna M.1, a 225B model with a 256K context window) is served through an OpenAI-co agents apis-json artificial-intelligence code-generation coding-assistant company developer-tools enterprise foundation-models inference llm machine-learning openai-compatible", "url": "https://github.com/api-evangelist/poolside", "upvotes": 0, "comments": 0, "sub": "github", "signal": 5.0, "hits": [] }, { "src": "github", "id": "1312943911", "title": "VNDT1625/TomniHubOs", "body": "TomniHubOS — an open-source agentic desktop OS with multi-provider AI, IDE Understanding, MTUI context tooling, MCP integrations, and engineering benchmarks. ai-agents developer-tools electron llm mcp typescript", "url": "https://github.com/VNDT1625/TomniHubOs", "upvotes": 0, "comments": 0, "sub": "github", "signal": 5.0, "hits": [ "benchmark" ] }, { "src": "github", "id": "1247675721", "title": "api-evangelist/hyperbrowser", "body": "Hyperbrowser — independent third-party profile of a public API surface, by API Evangelist. Hyperbrowser provides cloud browser infrastructure tailored for AI agents, bundling managed Chromium sessions with web scraping, crawling, and data-extraction APIs. The platform ships the open-source HyperAgent framework and first-class integrations for Brows ai-agents apis-json browser-automation browser-infrastructure captcha-solving computer-use data-extraction headless-browser hyperagent mcp proxies stealth web-crawling web-scraping x402", "url": "https://github.com/api-evangelist/hyperbrowser", "upvotes": 1, "comments": 0, "sub": "github", "signal": 5.0, "hits": [] }, { "src": "github", "id": "1333868070", "title": "sandbaseai/deepseek-harness-handbook", "body": "Agent-first DeepSeek Harness handbook: 173 source-backed runtime, plugin, MCP, sandbox, evaluation, troubleshooting, multilingual, and 74-resource Awesome ecosystem guides. agent-runtime agentic-ai ai-agents awesome-list deepseek deepseek-harness developer-tools llm mcp sandbox", "url": "https://github.com/sandbaseai/deepseek-harness-handbook", "upvotes": 88, "comments": 3, "sub": "github", "signal": 5.0, "hits": [] }, { "src": "github", "id": "1159915679", "title": "mj9733246-cloud/code-review-expert", "body": "🛠️ Enhance code quality with structured reviews, focusing on architecture, security, performance, and code hygiene for robust development. ai ai-code-completion ai-coding-tools automation benchmark claude claude-ai claude-code code-generation code-review developer-productivity llm open-source prompt-engineering repository-level-context software-engineering web3", "url": "https://github.com/mj9733246-cloud/code-review-expert", "upvotes": 0, "comments": 0, "sub": "github", "signal": 5.0, "hits": [ "benchmark" ] }, { "src": "github", "id": "1248954361", "title": "exha1078/agentic-workflow-orchestrator", "body": "🚀 GenAI Agents Production Blueprint 2026: Code-First Enterprise Deployment agent agent-framework agents ai-agents deployment genai generative-ai langgraph llm llms mlops production python tutorials", "url": "https://github.com/exha1078/agentic-workflow-orchestrator", "upvotes": 1, "comments": 0, "sub": "github", "signal": 5.0, "hits": [ "langgraph" ] }, { "src": "stackoverflow", "id": "78287327", "title": "Is there a framework of many open-source code LLMs for generation?", "body": "frameworks code-generation benchmarking huggingface-transformers large-language-model", "url": "https://stackoverflow.com/questions/78287327/is-there-a-framework-of-many-open-source-code-llms-for-generation", "upvotes": 1, "comments": 0, "sub": "stackoverflow", "signal": 5.0, "hits": [ "benchmark" ] }, { "src": "stackoverflow", "id": "14238657", "title": "How can I debug an internal error in the .NET Runtime?", "body": "c# .net", "url": "https://stackoverflow.com/questions/14238657/how-can-i-debug-an-internal-error-in-the-net-runtime", "upvotes": 69, "comments": 5, "sub": "stackoverflow", "signal": 4.5, "hits": [] }, { "src": "stackoverflow", "id": "17757248", "title": "Error - "There is no script engine for file extension .vbs" when using "Git Bash Here" in Windows 7", "body": "git vbscript", "url": "https://stackoverflow.com/questions/17757248/error-there-is-no-script-engine-for-file-extension-vbs-when-using-git-bash", "upvotes": 42, "comments": 7, "sub": "stackoverflow", "signal": 3.5, "hits": [] }, { "src": "stackoverflow", "id": "1043111", "title": "Transparent user session over several sites (single sign-on + single sign-off)", "body": "authentication session single-sign-on", "url": "https://stackoverflow.com/questions/1043111/transparent-user-session-over-several-sites-single-sign-on-single-sign-off", "upvotes": 39, "comments": 7, "sub": "stackoverflow", "signal": 3.3, "hits": [] }, { "src": "github", "id": "1152296003", "title": "dcellison/kai", "body": "Kai is a local, Telegram-first personal engineering system: a persistent AI collaborator with repo-aware coding, memory, scheduling, PR review, and multi-backend resilience. Your machine, your data, your rules. ai-agent automation developer-tools local-first multi-backend persistent-memory personal-engineering-system python self-hosted telegram-bot", "url": "https://github.com/dcellison/kai", "upvotes": 35, "comments": 6, "sub": "github", "signal": 3.0, "hits": [] }, { "src": "stackoverflow", "id": "51705471", "title": "Current state and solutions for OpenGL over Windows Remote", "body": "opengl opengl-es sdl remote-access glfw", "url": "https://stackoverflow.com/questions/51705471/current-state-and-solutions-for-opengl-over-windows-remote", "upvotes": 33, "comments": 4, "sub": "stackoverflow", "signal": 2.5, "hits": [] }, { "src": "hackernews", "id": "39460568", "title": "Show HN: I scraped 200M Shopify products to build a search engine", "body": "Hi HN! In December I launched an MVP for Agora here: https://news.ycombinator.com/item?id=38635695
After posting, we got thousands of users and hundreds of comments with valuable feedback from the community. I spent a couple sleepless nights frantically pacing around my room trying to keep the product live and, relatively, performant. After getting some sleep, I got back to work to make the product better.
A few updates:
1. We've grown from 25 million to 200 million products on Shopify and WooCommerce. The team at WooCommerce reached out after the HN launch to help us figure out how to index their stores. Similar to Shopify, we found that there’s a public file available for all stores that use Wordpress and WooCommerce at [Base URL]/wp-json/wc/v1/products. For example, the file for Good Works Tractors is available here: https://www.goodworkstractors.com/wp-json/wc/store/v1/produc... So I bought a list of 3.5 million active WooCommerce stores on a website called BuiltWith, adapted the product data model, and started the crawler to go down the list. We've indexed around 515k stores so far.
2. We improved the search experience. We're using Mongo to host the 200 million product records. First, we switched from Mongo Atlas Search to Typesense. After testing Typesense with our product records, we found most searches to be under 200ms. We're not storing the product images which slows down the loading speed at times. This week, we set up a server using Paperspace to run SBERT embeddings on a GPU (new to the AI workflow so apologies if I get the lingo wrong). We quickly realized that the dimension size of the embeddings matters a lot here, given the size of the data set. The GPU is still running to process all 200 million records and we're about a week away from releasing AI-powered search.
3. We localized the user experience. There's now frontend and backend IP detection to only show users products that are 'based in' or 'ship to' their specific country. This 'ships to' filter (i.e. stored in all Shopify stores in the /meta.json route like https://wildfox.com/meta.json) significantly slows down the search results but we're trying to get creative on the loading process and animation. For example, we're using Revalidating on Next.JS to give several pages a 'hard coded' feel and the data refreshes every 60 seconds. https://nextjs.org/docs/app/building-your-application/data-f...
4. We got our first few paying customers. Store owners can sign up for free to track their store's performance on Agora. We validate that they are the store owner by making sure the email address and store URL match on sign up, and then send them an email verification link. They can upgrade to a subscription tier to 'verify' their products to get better placement in relevant search results. Additionally, they can pay to 'boost' products and guarantee that they'll show up in the first row of results. Given the high purchase-intent searches on Agora, I'm finding this to be the right business model.
The next challenge to solve: We need to improve the quality of products on Agora. There's a lot of resellers, dropshipping stores, and low quality images. Now, just because a product is sold on a reseller or dropshipping website, doesn't mean it's a bad product. There's a lot of exceptions and edge cases to solve. One potential solution: we're considering coming up with an "Agora Score" that takes in several factors including the image quality, store name, brand name, website SEO, etc. to tell users how trustworthy we think the product is.
I'd love any feedback or advice. I did solve my original problem of finding 'red shoes' for my wife, but inadvertently created more problems for myself. I'm loving every minute of it though. My wife jokes that everything is now "Agora this...Agora that". Open to any advice on that as well.", "url": "https://www.searchagora.com/#", "upvotes": 23, "comments": 42, "sub": "hackernews", "signal": 2.2, "hits": [] }, { "src": "stackoverflow", "id": "11887816", "title": "Store Django Log messages in a database?", "body": "django logging", "url": "https://stackoverflow.com/questions/11887816/store-django-log-messages-in-a-database", "upvotes": 22, "comments": 5, "sub": "stackoverflow", "signal": 2.1, "hits": [] }, { "src": "stackoverflow", "id": "14023348", "title": "How to validate the origin of a web service invokation", "body": "android web-services security windows-phone-7 cryptography", "url": "https://stackoverflow.com/questions/14023348/how-to-validate-the-origin-of-a-web-service-invokation", "upvotes": 17, "comments": 6, "sub": "stackoverflow", "signal": 2.0, "hits": [] }, { "src": "github", "id": "1233368430", "title": "DonaldMurillo/gofastr", "body": "The full-stack Go framework that doesn't get in the way of you or your agents. Declare your domain in Go and get server-rendered screens, a REST API, OpenAPI, MCP tools, and migrations — plain Go you own. Experimental, stdlib-first. ai-agents full-stack go golang mcp orm rest-api server-side-rendering web-framework", "url": "https://github.com/DonaldMurillo/gofastr", "upvotes": 13, "comments": 6, "sub": "github", "signal": 1.9, "hits": [] }, { "src": "stackoverflow", "id": "43136293", "title": "Running Keras model for prediction in multiple threads", "body": "python tensorflow keras thread-safety reinforcement-learning", "url": "https://stackoverflow.com/questions/43136293/running-keras-model-for-prediction-in-multiple-threads", "upvotes": 23, "comments": 4, "sub": "stackoverflow", "signal": 1.9, "hits": [] }, { "src": "stackoverflow", "id": "28222548", "title": "How to disable context menu on right click/long touch in a kiosk mode of Chrome?", "body": "javascript google-chrome iframe kiosk-mode", "url": "https://stackoverflow.com/questions/28222548/how-to-disable-context-menu-on-right-click-long-touch-in-a-kiosk-mode-of-chrome", "upvotes": 24, "comments": 3, "sub": "stackoverflow", "signal": 1.8, "hits": [] }, { "src": "stackoverflow", "id": "583202", "title": "Mac OS X: Can one process render to another process's window?", "body": "macos process quartz-graphics window-handles", "url": "https://stackoverflow.com/questions/583202/mac-os-x-can-one-process-render-to-another-processs-window", "upvotes": 23, "comments": 3, "sub": "stackoverflow", "signal": 1.8, "hits": [] }, { "src": "stackoverflow", "id": "15429934", "title": "Client-Side CommunicationException while Service works properly", "body": "c# asp.net .net wcf exception", "url": "https://stackoverflow.com/questions/15429934/client-side-communicationexception-while-service-works-properly", "upvotes": 16, "comments": 5, "sub": "stackoverflow", "signal": 1.8, "hits": [] }, { "src": "stackoverflow", "id": "5254460", "title": "How can I get a password containing a caret (^) passed unchanged as a parameter to a Windows batch file?", "body": "windows batch-file cmd", "url": "https://stackoverflow.com/questions/5254460/how-can-i-get-a-password-containing-a-caret-passed-unchanged-as-a-parameter", "upvotes": 15, "comments": 5, "sub": "stackoverflow", "signal": 1.8, "hits": [] }, { "src": "stackoverflow", "id": "58861823", "title": "can I turn off optimization, so in-scope variables from closures aren't "optimized out"", "body": "javascript google-chrome optimization console v8", "url": "https://stackoverflow.com/questions/58861823/can-i-turn-off-optimization-so-in-scope-variables-from-closures-arent-optimiz", "upvotes": 22, "comments": 3, "sub": "stackoverflow", "signal": 1.7, "hits": [] }, { "src": "stackoverflow", "id": "994555", "title": "Windows: avoid pushing full x86 context on stack", "body": "exception assembly stack-overflow cpu-registers threadcontext", "url": "https://stackoverflow.com/questions/994555/windows-avoid-pushing-full-x86-context-on-stack", "upvotes": 14, "comments": 5, "sub": "stackoverflow", "signal": 1.7, "hits": [] }, { "src": "github", "id": "1194493251", "title": "HIDORAKAI002/ai-workspace-archive", "body": "A massive, self-updating local archive of AI tools — 11,000+ agent skills, 240+ MCP servers, 2,200+ IDE rules (Cursor/Cline), and 30+ system prompt collections. One repo to rule them all. agents ai antigravity automation claude claude-code claude-code-skill claude-code-skills claude-plugin claude-skills codex codex-desktop codex-pet codex-plugin codex-skill ide llm mcp mcp-servers prompts", "url": "https://github.com/HIDORAKAI002/ai-workspace-archive", "upvotes": 32, "comments": 0, "sub": "github", "signal": 1.6, "hits": [] }, { "src": "github", "id": "1163714831", "title": "iliaal/whetstone", "body": "AI-powered development tools. 19 agents, 22 commands, 32 skills, 1 hook, 1 MCP server for code review, research, design, and workflow automation. agent-skills ai-agents ai-tools claude-code claude-code-plugin code-review developer-tools mcp-server skills", "url": "https://github.com/iliaal/whetstone", "upvotes": 32, "comments": 0, "sub": "github", "signal": 1.6, "hits": [] }, { "src": "stackoverflow", "id": "17243168", "title": "Which StatsD client should I use for a java/grails project?", "body": "java grails statsd", "url": "https://stackoverflow.com/questions/17243168/which-statsd-client-should-i-use-for-a-java-grails-project", "upvotes": 20, "comments": 3, "sub": "stackoverflow", "signal": 1.6, "hits": [] }, { "src": "stackoverflow", "id": "52973464", "title": "Set audio endpoint devices application specific (programmatically)", "body": "c++ audio windows-10 audio-streaming endpoint", "url": "https://stackoverflow.com/questions/52973464/set-audio-endpoint-devices-application-specific-programmatically", "upvotes": 20, "comments": 1, "sub": "stackoverflow", "signal": 1.2, "hits": [] }, { "src": "stackoverflow", "id": "14693724", "title": "How can I set the RTS with ioctl() in a Mac plugin?", "body": "c++ macos plugins serial-port ioctl", "url": "https://stackoverflow.com/questions/14693724/how-can-i-set-the-rts-with-ioctl-in-a-mac-plugin", "upvotes": 16, "comments": 2, "sub": "stackoverflow", "signal": 1.2, "hits": [] }, { "src": "stackoverflow", "id": "79722494", "title": "IntelliJ IDEA: Cannot run program "C:\\Program Files\\nodejs\\npx": CreateProcess error=193 when using MCP server", "body": "node.js windows intellij-idea npx model-context-protocol", "url": "https://stackoverflow.com/questions/79722494/intellij-idea-cannot-run-program-c-program-files-nodejs-npx-createprocess-e", "upvotes": 8, "comments": 4, "sub": "stackoverflow", "signal": 1.2, "hits": [] }, { "src": "stackoverflow", "id": "3793215", "title": "Query OLAP Mondrian (MDX, XMLA) with a Python interface?", "body": "python mdx olap psycopg2 xmla", "url": "https://stackoverflow.com/questions/3793215/query-olap-mondrian-mdx-xmla-with-a-python-interface", "upvotes": 9, "comments": 4, "sub": "stackoverflow", "signal": 1.2, "hits": [] }, { "src": "hackernews", "id": "44245754", "title": "Why Vertical AI Agents May Replace RPA in Complex Enterprise Workflows", "body": "RPA helped with task-level automation, but today’s enterprise processes demand more than macros and scripts. We’re seeing the rise of AI agents—context-aware, multi-system, and even collaborative. Curious how others are seeing this shift from automation to orchestration. Thoughts?", "url": "https://news.ycombinator.com/item?id=44245754", "upvotes": 9, "comments": 3, "sub": "hackernews", "signal": 1.1, "hits": [] }, { "src": "stackoverflow", "id": "27450042", "title": "Windows Aero Rendering Bug", "body": "c++ windows qt winapi user-interface", "url": "https://stackoverflow.com/questions/27450042/windows-aero-rendering-bug", "upvotes": 15, "comments": 2, "sub": "stackoverflow", "signal": 1.1, "hits": [] }, { "src": "stackoverflow", "id": "18234484", "title": "Harvesting the power of highly-parallel computers with python scientific code", "body": "python concurrency parallel-processing multiprocessing scientific-computing", "url": "https://stackoverflow.com/questions/18234484/harvesting-the-power-of-highly-parallel-computers-with-python-scientific-code", "upvotes": 7, "comments": 4, "sub": "stackoverflow", "signal": 1.1, "hits": [] }, { "src": "stackoverflow", "id": "7843234", "title": "searching good embedded & hosting language pair", "body": "multithreading programming-languages vm-implementation", "url": "https://stackoverflow.com/questions/7843234/searching-good-embedded-hosting-language-pair", "upvotes": 3, "comments": 5, "sub": "stackoverflow", "signal": 1.1, "hits": [] }, { "src": "stackoverflow", "id": "66609054", "title": "ruamel_yaml.constructor.ConstructorError: could not determine a constructor for the tag 'tag:yaml.org,2002:python/tuple' in "<unicode string>"", "body": "python yaml conda ruamel.yaml", "url": "https://stackoverflow.com/questions/66609054/ruamel-yaml-constructor-constructorerror-could-not-determine-a-constructor-for", "upvotes": 11, "comments": 2, "sub": "stackoverflow", "signal": 1.0, "hits": [] } ]