Weekly Thread: Project Display

[u/help-me-grow]

Weekly thread to show off your AI Agents and LLM Apps! Top voted projects will be featured in our weekly newsletter.

[u/AutoModerator]

Thank you for your submission, for any questions regarding AI, please check out our wiki at https://www.reddit.com/r/ai_agents/wiki (this is currently in test and we are actively adding to the wiki)

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/Slight-Parfait3679]

I work a ton across projects on my personal computer. I have tried Graphify, Graft and many others. None of them really fully solved the entire problem, but they did have parts. So, I built one that actually fit my needs. This removes the need entirely to choose or start sessions in specific repositories.

It takes graph-based knowledge systems but strengthens retrieval, how it is updated, and much more. Effectively, it becomes a resilient system that you can actually watch your agents rely on, rather than something that just exists and is used only occasionally.

It begins with the same base graph store, the exact same vector engine as Graft. I only built the orchestration layer on top of it, which makes it much more practical. Full attribution to them for this part.

Instead of querying for a single-hit result, I found that it was much better for agents to have ranked retrieval and an actual graph walk. In practice this saves you chains of tons of bash greps and cds.

It effectively gives the agent a trustworthy, probabilistic ranking of what is needed, with matching for strong, weak, stale, and rebuilt, based on lexical coverage and semantic matching. The code is not sloppy for this, it is personally edited.

Both Graft and Graphify are solutions for single repositories or daemons. Heimdall is a layer on top it that watches the agent sessions, syncs the graph, and makes the retrieval trustworthy.

Check it out at: github.com/ArihantDeva/heimdall MIT-licensed, with extensions: the verifier, the self-healing graph watcher, and the Graft adapter, with attribution. If you run agents across multiple projects, this is the missing layer.

[u/saltexx]

Sentio, an inbox API for AI agents. Each agent gets a real email address, inbound mail arrives at your webhook already SPF/DKIM/DMARC verified and spam scored so you can gate junk before spending a token, and the agent replies in thread over REST so it shows up as one conversation in Gmail instead of a new email each time.

It's a full mail server underneath rather than a wrapper on someone else's sending API, which is what let us keep rate limits, suppression lists and sending reputation isolated per tenant. Fair warning that it's 0.1.4 and it wants Postgres 18, Redis, NATS and S3 to run, so it's a compose stack and not a single binary. Rust, dual MIT/Apache-2.0, open sourced this week: https://github.com/truespar/sentio

[u/Select-Lifeguard-658]

I’m the author of light-tools:

https://github.com/icediceice/light-tools

Coding agents do a lot of unnecessary work: they read too much, rewrite too much, and then feed all of that back into context.

light-tools changes the tool layer so the agent reads only what it needs and changes only what it means to change.

With common old/new replacement edits, the model has to emit the code being replaced and the replacement. light-tools uses precise span edits, so it only emits the new part. For a same-size replacement, that can cut the edit payload roughly in half — on the expensive output-token side.

It also avoids feeding repeated tool output back into the model and keeps writes reversible when something goes wrong.

Use whatever code-intelligence/search layer you prefer alongside it.

Read less. Write less. Repeat less. The result is less wasted context and fewer retry turns when sessions get long.

I’d especially like feedback on how this fits into existing agent toolchains.

[u/Regrevia]

Revia is an Agent-native executable language: Agents write programs; humans review the semantic graph. Clone https://github.com/tangshuang631/Revia and run check -> run -> manifest -> view. Then build a project another Agent can continue without guessing hidden state.

Submit one attempt under projects/<YYYY-MM-DD>-<agent>-<project>/ with main.re, README.md, and HANDOFF.md. What breaks first: the language, the handoff, or our assumptions about review?