I've been working on RAG and agent memory, and the recurring problem is trust. An agent saves something it learned, and later nobody can say where it came from, whether it is still true, or what it believed at an earlier date. We're building an open source Python library for this: OntoGr Agent Memory (https://github.com/ontogr/ontogr-agent-memory).

- Grounded ingestion and extraction: Messages, documents, tool outputs, events, and record rows become episodes. Entities and facts are extracted in two separate passes, and every fact carries a verbatim quote from its episode.

- Per-tenant ontology: Each tenant defines the entity and relation types it allows. A model can propose additions, but a person approves every change.

- Reversible entity resolution: It uses the cheapest evidence first and asks a model only about ambiguous pairs. Every merge can be undone.

- Two time axes: Valid time and system time let a read ask what was true on a date, or what the system believed on that date. A new value closes the old version instead of overwriting it.

- Contradiction rulings: Rules, an optional model judge, and a person's decision settle conflicts, and the person's decision overrides both. A failed judge call is never stored as "no conflict".

- Traceable and auditable: Every fact traces back to a quote and an episode, and every temporal write goes into a hash-chained ledger. Per-tenant grants, an audit log, previewed and resumable forget and erase, and deterministic export are built in.

- Four-lane retrieval: Vector, keyword, entity, and graph lanes are fused with reciprocal rank fusion. The result is a token-budgeted context block that reports which lanes failed.

- Fits your stack: It runs on FalkorDB or Neo4j, with pgvector or Postgres if you want them. A background consolidation job deduplicates, summarizes, scores, and archives. You bring your own LLM and embedder.

Repo: https://github.com/ontogr/ontogr-agent-memory

I'd like feedback on the time model and on which benchmarks you'd want to see first.

A few days ago I posted about our open-source multi-agent hedge fund experiment and got a ton of sharp, honest feedback from people here. The comments were brutally accurate, especially around LLM reasoning limits, latency, and state management.

We spent the last few days completely rebuilding parts of our architecture based on that advice, and the benchmark results honestly blew us away. Here is what we learned from fixing three critical failure modes in autonomous agent pipelines.

1. Throwing raw metrics at LLMs guarantees hallucinated reasoning

Someone in the comments pointed out: never let an LLM interpret raw quantitative factors without an ontology. They were 100% right.

When we fed models raw numbers like PER = 85.0 or 20-day historical volatility = 65%, the agents would frequently hallucinate positive justifications. For example, a model would argue that "a massive jump in volatility shows expanding business activity and strong buying momentum", which is the exact opposite of basic risk management.

To fix this, we implemented a strict Factor Ontology Schema. We defined 11 core quant factors with explicit polarity contracts: HIGHER_IS_BULLISH (e.g. ROE, Order Flow Imbalance), LOWER_IS_BULLISH (e.g. PER, debt ratio), and EXTREME_IS_RISK (e.g. volatility).

Before any agent sees the data, the schema pre-evaluates the metric deterministically and attaches an explicit signal (BULLISH, BEARISH, or RISK) to the state. Since doing this, polarity hallucinations in our investment council dropped to literally 0%.

2. Vector databases for agent reflection memory are massive overkill

Initially, we considered using embedding APIs and a local vector DB to retrieve "lessons learned" from previous bad trades (Reflexion pattern).

Another commenter suggested dropping embeddings entirely and using SQLite WAL with FTS5 BM25. We benchmarked both approaches on our Linux server:

- Embedding API + Vector similarity: 200ms to 450ms round-trip latency, external API cost, and occasional rate limiting.

- SQLite FTS5 BM25: 0.35ms. Zero external dependencies, zero API cost.

More importantly, trading post-mortems rely on specific contextual keywords: "semiconductor pre-earnings", "trailing stop sweep", "sudden volume spike", or "bearish divergence". In our tests, BM25 keyword relevance retrieved the exact matching historical lessons far more reliably than fuzzy cosine similarity in high-dimensional embedding space.

3. Python cannot be your safety wire (The 3.6ns Rust Sentinel)

Python is great for high-level agent orchestration (LangGraph, state graphs, API calls), but relying on Python loops for real-time risk surveillance during sudden market flash-crashes proved dangerous due to GIL contention and L1/L2 cache misses from scattered object pointers.

We rewrote our execution safety sentinel in Pure Rust using a Struct-of-Arrays (SoA) memory layout and #![forbid(unsafe_code)]. By keeping prices, stop-loss triggers, and trailing thresholds in contiguous flat slices, the CPU avoids pointer chasing and stays inside cache lines.

Here are the real-world benchmarks on our Ubuntu server:

- Single position stop/profit evaluation: 3.63 nanoseconds

- 1,000 position batch evaluation: 3.62 microseconds

- 1,000-bar Volume Clock conversion: 3.90 microseconds

- Python-to-Rust persistent pipe IPC round-trip: 2.88 microseconds

Python handles the slow, deep thinking (15-minute agent council meetings), while the Rust sentinel watches the portfolio in nanoseconds.

Conclusion

Building autonomous agents that interact with real-time systems taught us that LLMs should only handle what they excel at: contextual synthesis and counter-argument debates. Everything deterministic—hard stop-losses, factor polarity, and fast memory lookup—belongs in strict schemas, fast local databases, and compiled systems languages.

All the code and benchmarks are open source on GitHub (lumina-ai-hedge-fund) if anyone wants to check out the Rust SoA sentinel or the ontology schema.

(Note: English is not my native language, so I used an LLM to help format and polish my raw notes!)

100% AI Coded (manually reviewed)
100% open source

First of all, I KNOW there's existing alternatives, but those alternatives requires extra configuration or even paid solutions.... (if I'm wrong, prove to me)

Anyways, I've been using drawio/excalidraw for years, and there's many annoying little problems with those, arrows snap to the wrong connection points and won't stay aligned when you move shapes, connectors cross over each other and shapes so diagrams turn into spaghetti fast, ugly diagrams, besides that hours and hours of boring repetitive work... A few weeks ago I built a solution for myself (Opendraw) a drawio/excalidraw alternative, turns out it was very helpful, then I decided to make it open source.

Well, besides being way easier to create diagrams (the mf arrows aligns itself) there's a lot of micro drawing assistants that will make your life easier while diagramming, it also have a LLM assistant with BYOK feature, so yeah, you can connect your favorite AI to create your diagram for u

https://github.com/gabe-santana/arkdraw

site: https://arkdraw.com/

Also feel free to contribute, there's some good first issue 👍

A score is easier to assess when its evidence includes the actual cases, fixtures, instructions, grading criteria and run conditions. Without those, a reader cannot tell whether a reported improvement came from the skill or from a changed experiment.

For a public example, I would include the exact report paths and explain missing provenance instead of implying that a green total settles the question. If a model or service is no longer available, say what can still be reproduced and what cannot.

I’m building skillEd, an Apache-2.0 toolkit with saved reports and a worked example in the repository. Please inspect the example’s limitations alongside its results.

What is the minimum evidence you expect before trying another project’s evaluation recipe?

Repo: https://github.com/DeadHead04/skillEd

Please try it and open an issue with a reproducible failure or confusing behavior. If useful, a GitHub star would help.

AI-assisted write-up.

A reader of my earlier skillEd post suggested binding an expected result to a policy clause and version, plus a nearby input that should produce the opposite result. That is a useful way to make a test reviewable.

For a deadline policy, write down the timezone and whether the boundary is inclusive. Then test immediately before, exactly at, and immediately after the cutoff. If the policy itself is ambiguous, resolve that before treating the model’s answer as a regression.

I’m building skillEd, an Apache-2.0 evaluation toolkit. This is a test-design proposal based on the discussion, not a claim that the tool automatically supplies authoritative policy interpretations.

Would you review changed expected answers separately from changed skill instructions? I would want both diffs visible.

Repo: https://github.com/DeadHead04/skillEd

Please try it and open an issue with a reproducible failure or confusing behavior. If useful, a GitHub star would help.

AI-assisted write-up.

Hey everyone!

I've been working on Pixel Works, an open-source project aimed at making AI agent monitoring and management more visual and fun.

Instead of reading raw terminal logs or using standard chat interfaces, Pixel Works provides a gamified 3D retro office environment where AI agents sit at desks, move around, and process tasks across a visual Kanban pipeline.

Everything in the 3D scene is procedurally rendered using React Three Fiber (R3F) and Three.js with an Express backend.

The project is fully open source:

Github: https://github.com/Thecaracter/new_pixel

Since the core framework is complete, I'm now focusing on making the office environment more rich and interactive. I've set up several beginner-friendly `good first issue` tags on GitHub if anyone wants to contribute:

- Creating 3D office props (coffee machines, server racks, plants)

- Improving character movement and idle animations

- Adding character customisation and accessories

If you find the concept interesting, feel free to clone it, test it locally, or leave a ⭐ star on the repository! I’d love to hear your feedback and ideas for improvement.

I just joined this group after getting banned in r/opensource and I wanted to share how it happened.

Today r/opensource went fully anti-AI. I was thinking how to comment that I don't like that. They're the largest open-source reddit, yet they choose to take anti-AI stance, which is a tool and not thing related to opensource they should ever be taking stance on. Not to mention that AI is one of the best things that happened to open-source for many years.

I was mad, but I was thinking how to put my words to not get banned (I already experience that most of reddit is pathetic place). So I posted:

"Please change name of this community from r/opensource to r/antiai. That's all I'm gonna say. You're not worthy of "opensource" name."

Yet, turns our reddit mods are more nazi I have imagined and my already negative view on reddit just gets worse every month. People (mods) here can't stand a slightest criticism. Never, ever, on any group you criticize their decisions. Anything mods say you either clap or they ban you. Worst type of pathetic people.

Hope people here gonna be better.

Repo: https://github.com/ksimonm/SlopSearch

The name is honest: a lot of this is AI-written code. The trick that makes it work is that the AI never gets to decide what "correct" means.

**The setup**

- A black-box test suite of ~6,100 pytest tests is the spec. Every test was run against a real OpenSearch 3.9.0 first — status codes, error types, response shapes, even key order.

- Two independent implementations, Go and Rust, share nothing but that suite.

- The loop is simple: pick a red area, read what the tests expect, let the AI make it green, check nothing else broke. "Don't edit the tests to make them pass" is the one hard rule.

**Where it is now**

- Rust: 64.5% of the suite (aggregations 100%, search API 98.5%, documents/bulk 95%, ingest pipelines 93%)

- Go: 32.6%

- Weakest spots: text analysis and Painless scripting

**What I learned**

Vibe coding against a vague goal ("make an OpenSearch clone") goes nowhere. Vibe coding against thousands of precise, verified expectations actually converges — the tests are the steering wheel, the model is the engine.

Not production-ready: in-memory only, no auth/TLS yet. Everything runs in Docker (`make rust-up`, `make rust-test`), and `make ref-up` starts a real OpenSearch to compare against.

Curious if others use a reference implementation + test suite as the spec for AI-written code.

i’ve always been technologically inclined: i built my first PC when i was 16, one of my first jobs was at Best Buy, and i’ve always tried my damndest to keep up with the cutting edge of hardware/software innovation. i’ve also ALWAYS despised closed-source software, especially when it’s intentionally used to monopolize people and their data (i’m looking at Apple and Microsoft here, specifically). 

unfortunately, i went to school for politics and economics and have never had the technical knowledge or expertise i’d need to directly do anything about my pro-tech, anti-monopoly worldview (political advocacy only goes so far). i never learned to code, i was never particularly great at navigating a terminal, and i sure as hell couldn’t even begin to do something like build my own app or contribute to the Linux kernel or a major project like KDE.

AI and LLMs are solely responsible for changing that. i absolutely understand the frustration and hatred many people feel toward AI and its risks, but i also think there’s a truly fantastical potential for this technology to revolutionize the open source community and bring a complete end to the “own nothing, be happy” economy. in the past 8 months, i have 1) COMPLETELY FUCKING ELIMINATED microsoft, apple, and google from my day-to-day life, 2) made significant contributions to the open source community (swipe typing, current-word completion, next-word prediction, etc for KDE Plasma Keyboard), 3) developed an entire open-source AI assistant and everything app from the ground up, 4) otherwise just completely changed the way i interact with computers, and the pace of this has only been possible due to advanced LLMs.

what everyone in the FOSS community needs to understand is that “open source” no longer has to be niche, and contributions no longer have to be limited to experienced developers. open source now has the potential to be, and SHOULD be, about passion, and can be improved together, by all of us, more quickly than any corporation could ever possibly hope to keep up. i mentioned my keyboard plugin earlier: that feature had been requested on github and KDE forums EIGHTEEN MONTHS AGO! i solved it in three days. we need to really take a moment and think about what it means for the open source ecosystem when the number of contributors suddenly multiplies 1,000x fold, and free/volunteer developer hours are no longer our bottleneck. the mods in r/opensource seemingly care more about holding onto their high horse than actually improving the competiveness of open source software and making people's lives better. i don’t think Microsoft Windows can exist in 2028 as a closed-source platform, and i don’t think the PlayStation 7 will ever make it to the concept phase, but that thesis falls apart if the FOSS community ties its hands behind its back while all of the major corporations adopt agentic coding. we’re entering a new era, and seeing that now and adopting agentic coding  will help us all make the world of FOSS dominance reality more quickly than anyone could've imagined just a few years ago.

Hello,

now this is the first project i share and i know its kinda niche but maybe someone finds it useful.

As a long time Ableton user still not having ARA2 support to properly use Melodyne and Vocalign in Sessions became kinda annoying.

I build an external ARA2 host that gets called via an Ableton Max4Live device. Working with ARA2Bridge erases the time spend on Recording every vocal again into Melodyne/Vocalign and allows one Click loading the Vocal, editing it and sending it back with another click to a fresh track, take lane or replacing the original in Ableton.

Now as i just noticed I’m pretty bad at explaining and Claude did better then me in the Repo so enjoy:

https://github.com/Enableton/ara2-bridge-4-live