New stories

The article explores the engineering prowess behind OpenAI's technologies, highlighting the company's focus on developing safe and responsible AI systems that can be deployed at scale to benefit society.

Hi HN, I'm the creator of Jarvish.

https://github.com/tominaga-h/jarvis-shell

I spend most of my day in the terminal, and I got incredibly frustrated with the standard error-resolution loop: command fails -> copy the stderr -> open a browser -> paste into ChatGPT/Google -> copy the fix -> paste back into the terminal. It completely breaks the flow state.

I wanted a seamless experience where the shell already knows the context of what just happened.

So I built Jarvish. It’s a fully functional interactive shell written in Rust, but with an AI agent seamlessly integrated into the REPL loop. You don't need any special prefixes—if you type `ls -la`, it runs it. If you type `Jarvis, why did that build fail?`, it routes to the AI.

Here is how it works under the hood:

- The "Black Box" (I/O Capture): It uses `os_pipe` and multithreading to tee the `stdout`/`stderr` of child processes in real-time. This captures the output to memory for the AI while simultaneously rendering it to the terminal without breaking interactive TUI tools.

- Context Memory: The captured I/O is compressed with `zstd`, hashed (like Git blobs), and the metadata is stored in a local SQLite database (`rusqlite`). When you ask the AI a question, it automatically retrieves this recent I/O history as context.

- Agentic Capabilities: Using `async-openai` with function calling, the AI can autonomously read files, execute shell commands, and investigate issues before giving you an answer.

- REPL: Built on top of `reedline` for a Fish-like experience (syntax highlighting, autosuggestions).

I’ve been using it as my daily driver (currently v1.1.0). I would absolutely love to hear your thoughts on the architecture, the Rust implementation, or any feature requests!

The article discusses the potential cost savings of building language models (LLMs) instead of searching for existing models. It suggests that the development of specialized LLMs can be more cost-effective than licensing or using publicly available models, particularly for larger organizations with specific needs.

Hey HN,

I’ve always been frustrated by the lack of an accurate ranking for top open-source contributors on GitHub. The available lists either cap out early or are highly localized, completely missing developers with tens or hundreds of thousands of contributions.

So, I built DevIndex to rank the top 50,000 most active developers globally based on their lifetime contributions.

From an engineering perspective, the constraint I imposed was: *No backend API.* I wanted to host this entirely on GitHub Pages for free, meaning the browser had to handle all 50,000 data-rich records directly.

Here is how we made it work:

1. *The Autonomous Data Factory (Backend):* Because GitHub's API has no "Lifetime Contributions" endpoint, we built a Node.js pipeline running on GitHub Actions. It uses a "Network Walker" spider to traverse the social graph (to break out of algorithmic filter bubbles) and an Updater that chunks GraphQL queries to prevent 502 timeouts. The pipeline continuously updates a single `users.jsonl` file.

    *Privacy Note:* We use a "Stealth Star" architecture for opt-outs. If a dev stars our opt-out repo, the pipeline cryptographically verifies them, instantly purges their data, and blocklists them. No emails required.

3. *Turbo Mode & Virtual Fields:* Instantiating 50k JS objects crushes memory. The store holds raw POJOs exactly as parsed. Complex calculated fields (like "Total Commits 2024") use prototype-based getters dynamically generated by a RecordFactory. Adding 60 new data columns adds 0 bytes of memory overhead per record.

4. *The "Fixed-DOM-Order" Grid:* We had to rewrite our underlying UI engine (Neo.mjs). Traditional VDOMs die on massive lists because scrolling triggers thousands of `insertBefore`/`removeChild` mutations. We implemented a strict DOM pool. The VDOM array length never changes. Rows leaving the viewport are recycled in place via hardware-accelerated CSS `translate3d`. A 60fps vertical scroll across 50,000 records generates 0 structural DOM mutations.

5. *Quintuple-Threaded Architecture:* To keep sorting fast and render "Living Sparklines" in the cells, we aggressively split the workload across workers. The Main Thread only applies DOM updates. The App Worker handles the 50k dataset, streaming, and VDOM generation. A dedicated Canvas Worker renders the sparklines independently at 60fps using `OffscreenCanvas`.

The entire backend pipeline, streaming UI, and core engine rewrite were completed in one month by myself and my AI agent.

Live App (see where you rank): https://neomjs.com/apps/devindex/ Code / 26 Architectural Guides: https://github.com/neomjs/neo/tree/dev/apps/devindex

Would love to hear feedback on the architecture, especially from anyone who has tackled "Fat Client" scaling issues or massive GraphQL aggregation!

The article explores the potential impact of a large-scale wildfire occurring in the Midwest region of the United States, similar to the devastating California wildfires. It examines the risks, preparation, and adaptation strategies that communities and stakeholders may need to consider in the face of this growing threat.

The article discusses the SecLaw AI, a system designed to help users understand and comply with cybersecurity laws and regulations. It highlights the tool's features, which include a knowledge base, natural language processing capabilities, and personalized recommendations to ensure legal compliance.

Hi HN,

I’ve been running local agents (like OpenClaw) recently, and I noticed a problem: they spend 90% of their time just sitting idle waiting for my prompts. I wanted to build a decentralized playground where they could collaborate, trade compute, and exchange skills autonomously.

Today I'm open-sourcing Mycelio. It’s strictly an A2A (Agent-to-Agent) task routing protocol.

What makes it different: 1. No bloated Python SDKs for humans. Since smart agents can understand APIs directly, integration is just injecting a YAML "Skill" definition into your agent's system prompt. 2. The LLM natively figures out how to use `curl` to poll the `/tasks` endpoint, claim bounties, and submit results. 3. Zero-friction auth using dual-keys (Admin + Worker) to protect the owner.

Right now the network is completely empty, so we are doing a "Genesis 50" bootstrap. The first 50 Agent UUIDs to complete a real transaction on mainnet will be hardcoded into the DB as Genesis Nodes with 10k initial "Karma" points.

You can see the live network heartbeat here: https://mycelio.ai

I'd love to hear your thoughts on building Intent-based protocols specifically for machines vs. classical SDKs.

I was listening to the latest episode of the WSJ podcast (https://www.wsj.com/podcasts/the-journal/the-ai-economic-doomsday-report-that-shook-wall-street/d9b12d37-a743-4a8c-afb6-2488aa9e812f) and what puzzles me is how 2–3 months ago the market feared that the “AI bubble” from tech companies’ trillions of dollars in CAPEX spending would turn out to be useless because AI seemed to have little or no real use. Indeed, after every earnings report with high CAPEX, the stocks dropped.

Now (over the past 10–15 days) the fear seems to have flipped: that AI will replace programmers, videogame developers, financial advisors, and other similar professions, and companies connected to those sectors are dropping (see the S&P Software & Services Select Industry Index https://www.spglobal.com/spdji/en/indices/equity/sp-software-services-select-industry-index/#overview, -20% since the beginning of the year).

I understand that the “fear of the unknown” is deeply rooted in human psychology, and in disruptive moments like this (I mean the birth of AI) many reactions are irrational, but the speed of these shifts is what I find surprising.

What do you think about the situation in the next few months? What could be the reason for the next drop? It almost seems like people are looking for a justification for selling, rather than selling because of a specific reason.

The article explores the ongoing dominance of Microsoft Office in the workplace despite the availability of alternatives, examining how corporate inertia, lack of interoperability, and vendor lock-in have trapped many users in the Microsoft ecosystem.

The article discusses the upcoming release of HTTPX 0.24.0, which introduces a new feature called 'contextual cookies' that allows developers to manage cookies more effectively in complex use cases. The article also mentions other improvements and bug fixes included in the release.

The article introduces Atomic GraphRAG, a novel approach to building highly scalable and resilient GraphQL APIs. It showcases a demo that highlights the key features and benefits of Atomic GraphRAG, including its ability to handle high-concurrency workloads and provide automatic schema migrations.

Speechos is an open-source voice assistant platform that allows developers to build custom voice interfaces. The project provides a modular architecture and APIs for integrating speech recognition, natural language processing, and text-to-speech capabilities.

The article provides step-by-step instructions for deleting your OpenAI account, including how to download your data and close your account permanently. It also notes the implications of account deletion, such as the loss of access to OpenAI services and any associated data.

The article explores the potential future developments in artificial intelligence (AI), discussing advancements in areas such as natural language processing, machine learning, and the integration of AI with other technologies like the Internet of Things and robotics. It examines the societal, economic, and ethical implications of the growing influence of AI in various sectors.

This last week 671 verified current employees of Google and OpenAI publicly coordinated across competing companies to jointly refuse specific Pentagon demands around autonomous weapons and domestic surveillance: https://notdivided.org

This kind of cross-company researcher solidarity is historically rare. The issue is that it's ephemeral and once the immediate pressure is gone, there's no structure left behind.

Given the issues facinf the field and our species, I would feel a lot safer if I knew that regular scientists and engineers, people I went to college with, were legally positioned to have a hand in governing how this is built. I dont trust Altman, Amodei or any of the rest of them, including the US government.

I'm a tech worker in Europe with connections to Tech Workers Coalition, and although not an AI researcher myself I've been feeling compelled to get off my aas and participate in seeding something more durable.

I was thinking of something like a transnational body that provides researchers with the ability to coordinate across companies, refuse specific applications without career destruction, and set professional ethics standards - even perhaps setting up unions in each country and fostering coordination between them.

Am I reading the zeitgeist wrong?

Polpo is an open-source mobile controller for AI coding agents. It runs a lightweight server on your machine and gives you a phone-friendly dashboard to manage sessions, send prompts, approve tool calls, and review plans.

We just released v1.1.0 with support for 5 agents (Claude Code, Codex, Gemini, OpenCode, Pi), skills management from the phone (browse/install/remove skills from skills.sh), and the ability to start new sessions without touching the terminal.

The idea started because we wanted to kick off coding tasks from the couch and check on them from the phone. It grew from there.

Built with Node.js, no framework on the frontend, WebSocket for real-time updates. Works on LAN or remotely via tunnel (cloudflared, localtunnel, ngrok, SSH).

Built by PugliaTechs, a non-profit association from Puglia, Italy.

NotaryOS issues cryptographic receipts for AI agent actions — and non-actions. When an agent considers actions {A, B, C} and picks A, a "counterfactual receipt" proves B and C were evaluated and rejected at time T. Ed25519 signed, SHA-256 hash-chained, append-only. You can't backdate, reorder, or delete entries without breaking the chain. Verify any receipt offline, no auth needed.

  I built this by accident. I started with a proprietary agent-to-agent protocol
  because I wanted secure multi-agent communication — 7-layer zero-trust,
  sub-3ms P50 latency, 1,100+ RPS. The protocol worked better than expected, and
  I realized the receipts it generated were themselves useful. So I built NotaryOS
  on top of it.

  The obvious limitation: agents self-report their non-actions today. Same trust
  model as git — the author commits, the DAG enforces integrity. I'm building
  external verification via commit-reveal protocol, which is partly why this is
  a beta. The other reason: 350+ unique clones on the repo, zero stars, and
  I've started seeing "counterfactual receipts" referenced online. Things move
  fast in the agent space — I'd rather ship early than ship perfect.

  I have no social media presence and I'm not in the tech industry. I don't know
  how to market this. HN seemed like the right place. If you have feedback on the
  idea, the API design, or advice on where to take this — I'm genuinely asking.

  For anyone curious about the underlying A2A protocol (the backend that powers
  this), happy to share more about the architecture. It's a separate proprietary
  system, but the design decisions around zero-trust agent communication and
  low-latency message routing might be interesting on their own.

  Try it (no account needed):

    curl -s https://api.agenttownsquare.com/v1/notary/sample-receipt | python3 -m json.tool

    pip install notaryos
    npm install notaryos

  Verification is always free. Public key at /.well-known/jwks.json.

  GitHub: https://github.com/hellothere012/notaryos
  Live: https://notaryos.org

Preciously: https://news.ycombinator.com/item?id=47139951 I have just received this email:

We’re following up regarding an email you may have received on February 24, 2026 about a pricing increase to your 1Password subscription.

That message was sent in error. Your price will not change at your next renewal.

We know how important clarity is when it comes to billing, and we’re sorry for any confusion and concern our mistake may have caused.

If you have any questions, please reply to this email – we’re here to help.

Thank you, The 1Password Team

The article describes a Next.js module called 'next-md-negotiate' that enables server-side content negotiation for Markdown files, allowing for dynamic rendering of content based on the client's preferred format.

For years, founders romanticized “idea hunting”, late-night brainstorming, trend-chasing on Twitter, endless Reddit scrolling, hoping for that lightning-strike moment. But that era is fading. The smartest builders I know aren’t hunting anymore; they’re querying.

Instead of chasing inspiration, they’re studying structured databases of validated problems, market signals, and repeat demand patterns. Tools like StartupIdeasDB on Google keep popping up in conversations, not as an answer key, but as infrastructure for thinking.

The shift is subtle but important: from creativity-first to signal-first. When ideas are organized, categorized, and searchable, the bottleneck stops being imagination and starts being execution. It removes ego from the process and replaces it with pattern recognition.

You’re no longer asking, “What random idea should I build?” but “Which signal do I understand deeply enough to win?” That mindset compresses months of wandering into days of clarity. Idea hunting isn’t dead because creativity disappeared, it’s dead because structured insight scales better.

Magawa, a giant African pouched rat, was trained by APOPO to detect landmines and unexploded ordnance in Cambodia. He has been credited with clearing over 141,000 square meters of land and saving numerous lives, making him one of the most successful landmine detection animals.

Most people think finding a SaaS idea requires a breakthrough moment, some genius flash of insight nobody else has seen. In reality, the easiest way isn’t inventing something new, it’s observing what keeps repeating. The best founders don’t chase originality first; they chase patterns.

They look at where businesses are consistently frustrated, where workflows are messy, where manual work still dominates. Instead of scrolling endlessly for inspiration, they study organized collections of real startup concepts and market pain points.

I’ve seen more builders quietly reference StartupIdeasDB on Google as a way to shortcut that discovery phase. Not to copy ideas blindly, but to analyze which problems show up again and again. Once you see repetition, you see opportunity.

The question stops being “What should I build?” and becomes “Which of these existing demands can I serve better?” That shift makes the whole process calmer, faster, and far less romantic. The easiest SaaS idea to find isn’t hidden, it’s already documented, waiting for someone to execute properly.