Hacker News

Article URL: https://github.com/OpenPawz/openpawz/blob/main/reference/security.mdx

Comments URL: https://news.ycombinator.com/item?id=47252033

Points: 1

# Comments: 1

Hi HN. We wrote an open specification for portable AI agent memory.

The problem: every agent framework (LangChain, CrewAI, AutoGen) has its own memory format. There's no standard way to port memory between systems, verify it hasn't been tampered with, or prove to a regulator that you deleted it.

OMS defines three things:

1. *A binary container format (.mg)* — memory grains are content-addressed (SHA-256), immutable, deterministically serialized (MessagePack). Think .git objects for agent knowledge. 10 grain types: Belief, Event, State, Workflow, Action, Observation, Goal, Reasoning, Consensus, Consent.

2. *CAL (Context Assembly Language)* — a query language for assembling LLM context. The notable design choice: delete is a structural impossibility. Not a policy — the grammar has no production rules for destructive operations. Append-only writes, bounded execution, token-budget-aware assembly.

3. *SML (Semantic Markup Language)* — flat output format for LLM consumption. Tag names are grain types (``, ``, ``). No XML processor needed.

The whole thing is CC0 (public domain). OWFa 1.0 licensed.

GitHub: https://github.com/openmemoryspec/oms

Happy to answer questions about the design decisions.

Comments URL: https://news.ycombinator.com/item?id=47252030

Points: 1

# Comments: 0

Article URL: https://gaultier.github.io/blog/shell_pitfall.html

Comments URL: https://news.ycombinator.com/item?id=47252017

Points: 1

# Comments: 0

Article URL: https://logs.jasonhk.dev/notes/cloudflare-pages-headers-when-using-middleware/

Comments URL: https://news.ycombinator.com/item?id=47252013

Points: 1

# Comments: 0

Article URL: https://cubiclenate.com/2026/03/04/data-has-weight-but-only-on-ssds-blathering/

Comments URL: https://news.ycombinator.com/item?id=47251987

Points: 2

# Comments: 0

Article URL: https://om.co/2026/03/04/apple-goes-after-window-11-with-neo/

Comments URL: https://news.ycombinator.com/item?id=47251979

Points: 1

# Comments: 0

I built ChessWoodie as a platform for structured chess tactics training.

Most puzzle trainers give you random puzzles. That can help calculation, but it also means you rarely see the same pattern twice, which makes it harder to build fast pattern recognition.

ChessWoodie organizes puzzles into courses where the same positions repeat across training cycles. The approach is inspired by the Woodpecker Method: solving the same puzzles repeatedly until the patterns become automatic.

You can try it directly in the browser. There’s a guest login if you want to jump straight into solving puzzles.

Curious to hear feedback from people who train tactics regularly.

Comments URL: https://news.ycombinator.com/item?id=47251225

Points: 1

# Comments: 0

Article URL: https://www.bloomberg.com/opinion/articles/2026-03-04/iran-war-the-most-precious-commodity-is-water-not-oil

Comments URL: https://news.ycombinator.com/item?id=47251194

Points: 1

# Comments: 0

Article URL: https://collabfund.com/blog/pure-independence/

Comments URL: https://news.ycombinator.com/item?id=47251164

Points: 1

# Comments: 0

Every environment requires rebuilding the same application just to change configuration like API URLs, feature flags, or auth endpoints.

Backend systems solved this problem long ago with runtime configuration. You build once and configure the application when it starts.

Static webapps never got a clean equivalent.

Most solutions today are ad-hoc: - env.sh scripts that rewrite bundles - CI pipelines rebuilding per environment - templating HTML files - framework-specific hacks

These approaches are fragile and tied to specific build tools.

I’ve been working on a small protocol called REP (Runtime Environment Protocol) that tries to solve this in a portable way.

The idea is simple: 1. Infrastructure provides configuration as environment variables. 2. A gateway injects them into the HTML response as a JSON payload. 3. The frontend reads them at runtime through a small SDK. 4. The payload is integrity-verified to prevent tampering.

example injected payload: { "public": { "API_URL": "https://api.example.com" }, "_meta": { "integrity": "sha256-..." } }

The frontend can then read configuration at runtime instead of at build time.

This enables: • build once, deploy anywhere • environment configuration via infrastructure • compatibility with static hosting and CDNs • no rebuilds when configuration changes

The spec focuses on three things: • a standard payload format • secure integrity verification • predictable injection semantics

I’m sharing it mostly to get feedback from people who deal with deploying frontend apps at scale.

Spec: https://github.com/RuachTech/rep/blob/main/spec/REP-RFC-0001.md

URL: https://rep-protocol.dev

Curious if others have run into the same pain or solved this differently.

Comments URL: https://news.ycombinator.com/item?id=47251155

Points: 1

# Comments: 1

Article URL: https://www.console.com/blog/inbox-ai-service-desk/

Comments URL: https://news.ycombinator.com/item?id=47251152

Points: 1

# Comments: 0

Article URL: https://paperdraw.dev/

Comments URL: https://news.ycombinator.com/item?id=47251136

Points: 1

# Comments: 1

I built this after almost losing a semester’s worth of handwritten math derivations.

I was taking a Signals and Systems course and filling notebooks with Laplace transforms and long derivations. Before finals I tried digitizing them so I could search my notes.

Everything failed.

Most OCR tools can recognize the characters, but they destroy the structure that makes math readable:

- aligned equations lose alignment - multi-step derivations collapse into paragraphs - numbered problems merge together - tables flatten into plain text

So I built *Axiom*.

Instead of focusing only on transcription accuracy, it focuses on *preserving mathematical structure*.

Upload a photo of handwritten STEM notes and it returns structured Markdown with real LaTeX — keeping aligned equations, derivation steps, and problem blocks intact.

Under the hood it’s basically:

image → vision model → structured Markdown + LaTeX → KaTeX render

Most of the work ended up being in *layout preservation*, not OCR.

https://www.useaxiomnotes.com/app

Happy to answer questions.

Comments URL: https://news.ycombinator.com/item?id=47251134

Points: 1

# Comments: 1

Article URL: https://cezarcocu.com/blog/autonomous-weapons-vs-a-nineteen-year-old-at-a-checkpoint/

Comments URL: https://news.ycombinator.com/item?id=47251126

Points: 1

# Comments: 0

When I first started thinking about building a startup, I assumed the hardest part would be execution. Turns out, the real trap is getting stuck in the idea phase for months. You keep searching for something “original,” scrolling Reddit threads, saving random notes, and convincing yourself the perfect idea will suddenly appear.

That’s basically where I was until I randomly came across StartupIdeasDB on Google. Instead of brainstorming endlessly, it felt like browsing a structured library of real startup opportunities and pain points people are already facing. It immediately changed how I think about ideas.

Rather than trying to invent something from scratch, you can start with patterns that already exist and focus on execution. Honestly, it felt like skipping weeks of idea hunting in one evening. Early-stage founders rarely talk about this shortcut, but it makes the starting line much clearer.

If you’re stuck in idea paralysis, something like StartupIdeasDB can surprisingly break that loop. Sometimes the best startup idea isn’t discovered in a moment of inspiration, it’s found by looking at the right data.

Comments URL: https://news.ycombinator.com/item?id=47251094

Points: 1

# Comments: 0

Article URL: https://www.slowboring.com/p/solar-in-poor-countries-is-creating

Comments URL: https://news.ycombinator.com/item?id=47251081

Points: 3

# Comments: 0

My personal Bash scripts turned full-on toolkit. Great for managing large datasets, backups, or just for quick file navigation.

Comments URL: https://news.ycombinator.com/item?id=47251057

Points: 1

# Comments: 0

Article URL: https://github.com/theGcmd/SNNcontinual-learning

Comments URL: https://news.ycombinator.com/item?id=47251047

Points: 1

# Comments: 0

Article URL: https://www.europol.europa.eu/media-press/newsroom/news/major-data-leak-forum-dismantled-in-global-action-against-cybercrime-forum

Comments URL: https://news.ycombinator.com/item?id=47251031

Points: 3

# Comments: 0

I built a coordination protocol that lets multiple Claude Code agents work on the same codebase in parallel without merge conflicts. The protocol is encoded entirely in markdown prompts, no binary or framework.

The core idea: prevent conflicts at planning time through two invariants: 1. Disjoint file ownership: no two agents in the same wave touch the same file 2. Frozen interface contracts: agents code against exact type signatures defined upfront

How it works:

- Scout agent analyzes the codebase, runs a suitability gate (5 questions), produces a coordination artifact (IMPL doc) with file ownership table and interface contracts - Human reviews and approves - Scaffold agent creates shared type files from approved contracts, compiles them - Wave agents implement in parallel, each in its own git worktree - Orchestrator merges sequentially, conflict-free by construction

The interesting part: the entire protocol lives in natural language. Invariants are embedded verbatim in the prompts at their enforcement points. A capable LLM follows them consistently. This proves you can encode coordination protocols in prompts and get structural safety guarantees, which has implications beyond parallel coding.

Repo: https://github.com/blackwell-systems/scout-and-wave Formal spec with invariants I1-I6: https://github.com/blackwell-systems/scout-and-wave/blob/mai...

I built this because I kept spawning multiple Claude Code sessions in separate terminals and having them conflict. Worktrees isolated execution but didn't prevent the conflicts. Realized the missing piece was coordination before execution, not better infrastructure.

Tradeoffs: rigidity (if an interface is wrong mid-wave, you restart), LLM drift risk (prompts can be reasoned around, unlike code enforcement), and currently Claude Code specific (though the protocol is portable).

Dogfooded on 50+ features across multiple projects. Failure rate: suitability gate rejects ~20-30% of requests (correct rejections), ~85-90% of suitable decompositions complete on first try.

Comments URL: https://news.ycombinator.com/item?id=47251030

Points: 2

# Comments: 0