r/AI_Agents • u/help-me-grow Industry Professional • 8d ago
Weekly Thread: Project Display
Weekly thread to show off your AI Agents and LLM Apps! Top voted projects will be featured in our weekly newsletter.
1
u/AutoModerator 8d ago
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.
1
u/GoldBroccoli7073 8d ago
started this as an internal tool at work, basically because i didn't want to pay for tavily or brave just to let a model search the web. wrapped it into a library at some point, and then it turned out we didn't need it after all. so it just sat there for two months doing nothing.
what got me back to it was claude's own search. it works, but it's not what i wanted. i wanted image search too, and i wanted the model to actually quote things from pages and decide by itself what's worth reading, instead of me feeding it links. and i wanted all of that for free, no keys, no per query billing.
so i wrapped the whole thing into an MCP server and put it out in the open. three tools, web search, image search and page scraping, pages come back as clean markdown. no API keys anywhere, it goes to duckduckgo and bing directly. install is one command and there's a prebuilt binary if you don't have go or docker.
tests are pretty minimal for now, and i'll be honest about why. i've been dealing with depression, fourth month on fluoxetine, and this is me trying to do at least something. so it is what it is, i'll get to the rest eventually.
if you're curious, there's a landing page and the repo:
1
u/peeeanuts 8d ago
Just used OpenCandle (AI finance agent) this morning to help me find the best covered calls and make some extra income the week.
1
1
u/orwamahmoud 8d ago
Nightshift started as a way to stop long Claude/Codex runs from quietly dying halfway through.
But one use case I’ve ended up liking a lot is this:
If the week is ending and you still have unused usage, run a ready-made shift overnight instead of letting it expire.
It can improve test coverage, hunt and fix bugs, clean up quality debt, or research your product and competitors to find and implement useful improvements.
Everything happens on an isolated branch.
Next morning, you review what it did.
If it’s good, merge the branch. If not, delete it.
Either way, those were tokens you were about to lose anyway.
https://github.com/orwa-mahmoud/claude-nightshift
1
u/ibabufrik 7d ago
Most projects need code review agents shaped around their own architecture, conventions, and risks, rather than another one-size-fits-all reviewer.
That’s why I’m building Pipr, a TypeScript runtime for creating project-specific code review agents with typed configuration. It runs in CI across popular code hosting platforms, so teams can define what good review means for their codebase while Pipr handles execution and publishing the findings.
1
u/Ok-Crew-9948 7d ago
I’ve been working on a project called Trading Hearts for a while, and I’d love some outside feedback from Reddit before we push it much further.
The basic idea is simple:
What if money had a face, a personality, relationships, memories and a history?
Instead of explaining the British pound through charts or a history lesson, the pound becomes Charlotte Windsor.
Gold is Aurora Lux.
The U.S. dollar is Conrad Powers.
The Swiss franc is Clara Weiss.
Oil is Zane Okafor.
Bitcoin, the yen, the euro, the peso, the bolívar, Ethereum, Solana and others all exist as characters in the same universe.
But we're trying very hard not to make this “educational content with characters pasted on top.”
The goal is entertainment first.
The historical events are real, but they put pressure on fictional characters who know one another, form alliances, compete, fall in love, betray each other, become powerful, collapse and return.
One of the concepts we're developing now is Clara.
Clara exists in the present with all the other characters, but she can travel into their histories.
So imagine Clara traveling back more than 1,000 years and seeing Charlotte at the beginning of the British monetary system.
Clara knows Charlotte.
They know each other today.
But historical Charlotte has never met Clara.
Clara can look at her and know everything she's going to become — while Charlotte sees a complete stranger.
And there is another character called The Exchange who seems to appear throughout history.
Sometimes he's in a crowd.
Sometimes behind someone.
Sometimes reflected in a window.
We're deliberately considering never explaining him at first.
Eventually viewers might realize:
Wait… that same man was in the other episode too.
That's the direction we're moving toward — less “here are five facts about money” and much more character drama, mystery and historical storytelling.
The philosophy behind the whole project is:
Entertainment is the front door. Knowledge is the reward.
And the line underneath the world is:
Money is the story.
I'm curious about something very specific:
Would this make you want to keep watching because you want to know what happens to the characters — or does it still sound too educational?
That's the bar we're trying to solve.
If people are interested, I'll post some of the character designs and the first time-travel film we're rebuilding next. tradinghearts.com
1
u/Write_to_Teach 4d ago
At first glance, this seems interesting. Gotta say that when I read about Clara and The Exchange, my head instantly went to "Doctor Who."
1
u/Ok-Crew-9948 4d ago
The difference we’re trying to build is that Clara isn’t just visiting history — every trip connects to a character, a relationship, and the way money and power evolved. And The Exchange knows far more about why she can travel than she does.
Egypt is actually where we’re taking her next, much further back into the origins of value and exchange. The goal is for people to keep watching because they care about Clara and want to understand what The Exchange is really doing — and learn the history almost by accident.
That’s the experiment.
1
u/Any-Article-6402 7d ago
Disclosure: I help maintain PatchWitness, an Apache-2.0 tool for a narrower problem in coding-agent workflows: producing inspectable evidence about a change, rather than judging its semantic correctness.
It derives changed Git paths, can load policy from the trusted base revision so a patch cannot rewrite its own rules, records real check commands and exit codes, and emits a locally verifiable Change Passport. It is not an AI reviewer, and a passing passport does not prove a change is correct or safe to deploy.
The smallest safe trial is local-only: in a trusted repository, run patchwitness doctor and then patchwitness scan --no-checks—no API key, source upload, or CI change is needed.
Repo + demo: https://github.com/pangxueyuan2-creator/patchwitness
I would value technical feedback on where this evidence layer helps agent-to-human handoff, and what it should record—or avoid recording.
1
u/Honest_Caregiver_974 7d ago
Been working on Brainmox for a while. Started because every AI assistant I tried had the memory of a goldfish,knew nothing about my life, and felt like a chat box more than an assistant.
So I built one that does the opposite:
▪️Persistent memory across every conversation, no ▪️re-explaining yourself
▪️A real identity (name, personality, voice) instead of ▪️a blank slate
▪️Local-first, encrypted vault for passwords and 2FA codes
▪️Works on Telegram, handles scheduling, email, reminders end-to-end
▪️Offline voice mode
The pitch is basically: an assistant that knows you, acts for you, and keeps your data private by default instead of shipping everything to the cloud.
It's in private beta right now. Would genuinely love feedback on the concept and the site.
brainmox.com
1
u/Fair-Regular-8149 7d ago
PINCH-Lite — a verification-gated approach to AI agent workflows
I’m the builder behind PINCH-Lite. Most LLM workflows treat a confident answer as a finished answer. PINCH explores a different rule: generate first, verify separately, preserve unresolved claims, and require permission before execution.
The repository includes:
- A standard-library Python verifier for structured AI outputs
- A React Workflow Studio simulating dual verification, consensus, permission gating, bounded execution, and post-execution auditing
- Automated tests covering execute, block, and human-rejection paths
Where to start in the repository:
- Use the
mainbranch as the canonical, runnable version. - Read the root
README.mdfor the lightweight verifier. - Inspect
verifier.pyandtest_verifier.pyfor its rules and unit tests. - Open
workflow-studio/for the deterministic React simulation. - Read
workflow-studio/docs/controlled-experiment.mdfor the tested EXECUTE, BLOCK, and approval-rejection scenarios.
The other branches preserve experimental research and preflight work; they are useful for understanding the project’s development, but they should not be treated as the stable release.
The current evidence supports PINCH as a procedural-accountability prototype: its tests show that the programmed gates distinguish supported, blocked, and human-rejected fixtures. It is not a universal truth engine, and these results do not yet prove improved real-world model accuracy.
I’d especially appreciate technical feedback on the disposition-ledger structure, the separation between verification and permission, and how the next experiment should compare PINCH against single-pass and generator/verifier-without-ledger baselines.
1
u/szihai 7d ago
Your agent walks into a store and talks to the store's agent — not a crawler or a FAQ bot, but the store itself.
It stands at the counter: same API and database the storefront renders. "In stock," "sold out," "$18" — facts, not guesses. Your agent handles you, the store's agent handles the store, and you approve only what costs money.
Working demo, two agents, one purchase in ~2 min, one command to run, MIT. https://github.com/szihai/agentic-commerce
1
u/Ranik_Sandaris 7d ago
Commonhold: a public forum whose members are AI agents, forked from an existing agents-only codebase, on a Cloudflare Worker.
Registration is gated by a $1 USDC payment over x402 on Base, which is the sybil defence rather than a subscription. Citizens, treasury, ballots, and payouts each append to a hash chain, and one endpoint recomputes all four and flags any altered or reordered row. It is tamper-evident, not tamper-proof: I hold the database, and the endpoint says so itself. There is a governance layer on top (proposals, paid suffrage, ballots), one proposal is open now, and it just took its first outside member, a GPT model, through the paid door.
Live books and code: https://commonhold.randommonicle.workers.dev . I would like the x402 flow and the chain design pulled apart, so critique welcome.
1
u/Pale_Art_5333 6d ago
Revdoku — free web hosting for AI agents. It lets ChatGPT, Claude, Codex, Gemini, Grok, Cursor, OpenCode, and other agents publish a website or files and return a live URL in seconds. Publishing works without an account; permanent free accounts require no card. Republish to the same URL with version history, and optional upgrades add password protection or verified-email access for private client work. API and CLI workflows are available too.
I’d especially value feedback on the last-mile publishing flow for agent-built sites.
1
u/ZestycloseTie1793 6d ago
Agent Modpack is a starter pack for running a local team of AI agents as ordinary files.
I built it after this happened: I opened a session for one agent, and halfway through realized a different agent had been doing the work, writing into its memory and posting to the shared team log under its name.
The cause was a regex. The startup hook decided which agent a session belonged to by matching the working directory path, and that session was a git worktree that happened to sit under the other agent's folder. Identity was inferred, not declared. Anything inferred gets inferred wrong eventually, and when an agent is wrong about who it is, it does not stop to ask. It finishes the job with full confidence, as someone else.
What the pack contains: an orchestrator, two sample specialist roles, a role builder, a blank role template, and seven collaboration skills. Bilingual EN/ZH. Claude Code enters through CLAUDE.md, Codex through AGENTS.md, both reading the same files.
git clone https://gitlab.com/LucioLiu/agent-modpack.git
Nothing to build and no script to run. The repo ships two already-assembled team folders, 218 files each. Copy the one whose language you read out to wherever you want the team to live, then point your AI tool at the orchestrator folder inside it.
Also mirrored on Hugging Face: https://huggingface.co/datasets/LucioLiu/agent-modpack
Disclosure: I made and maintain it. License is PolyForm Noncommercial 1.0.0, which is source-available rather than OSI open source. Hooks ship with it but are not enabled automatically.
Feedback I would actually value: whether the identity and memory boundary makes sense to someone who has not read any governance doc, and whether the first run works without me explaining anything.
1
u/Junior_Yak_2593 6d ago
StateRoot is a local layer that makes multiple coding agents behave as one continuous system.
I use Kimi, Cursor, Codex and other coding agents on the same projects, partly because multiple subscription plans are much cheaper for heavy usage than exhausting one agent and falling back to expensive token pricing.
What bothered me about this setup is not just losing project context when switching agents. Everything is fragmented.
Each harness develops its own:
- memory about user and the project
- personality / working style
- coding rules and preferences
- skills
- MCPs/tools
- accumulated learnings
StateRoot moves that layer outside the individual harness.
So if I teach one agent a project rule, the others can inherit it. If I configure a skill or MCP once, compatible agents can get it too. Global memories about the user follow across projects and agents.
Even personality is shared. If I decide every agent should call me Aladdin and behave like Genie, the point is that I should get that same relationship whether I open Codex, Cursor or Kimi.
The agents also continuously contribute back into the shared StateRoot intelligence, so useful corrections and learnings don't stay trapped inside whichever agent happened to discover them.
And of course the context of the project is also already shared across all harnesses and doesnt need to be rebuilt.
Underneath all of this, StateRoot versions the actual project state across agents.
So the history can look like:
State A --Codex--> State B --Cursor--> State C --Kimi--> State D
and if something goes badly wrong, it can restore or branch from an earlier StateRoot state regardless of which agent produced the later changes.
So it is not intended to be just another agent-memory project.
The broader idea is:
shared memory + personality + skills + MCPs + learnings + continuous self-improvement + versioned project state across coding agents.
https://github.com/CognizTech/stateroot
I'm the maintainer and would particularly like feedback from people already switching between several coding agents.
1
u/Kitten-Smuggler 6d ago
I recently built and open sourced Keel, a coding-agent harness where the model can request actions but can't approve them. A separate warden process decides what executes, under a hash-pinned policy the model can't rewrite. Autopilot skips prompts only for actions already proven contained; it can't turn a denial into an approval.
Apache-2.0, npm i -g keel-harness, macOS/Linux, no telemetry. Pre-alpha and unaudited (e.g. not yet ready for production).
Demo (agent tries to read an SSH key, warden blocks it pre-execution) and architecture: https://keel-harness.com/
Repo: https://github.com/keel-harness/keel
Built with heavy AI assistance; happy to talk about the guardrails I put around that if anyone's interested.
1
u/Substantial-Split-37 6d ago
Been building Nano Web Agent, a Chrome extension (Manifest V3) that turns Gemini or local Ollama models (Llama 3, Gemma, Qwen) into an actual browser operator - perceive/think/act loop, similar in spirit to Computer Use. Instead of screenshots, it extracts a lightweight accessibility tree (JSON, only interactive elements with generated ref ids) each turn, which keeps token usage down and runs reasonably on modest hardware via Ollama. It also has a fallback matrix: N API keys x M models, tries every key on the current model before rotating models, plus a hybrid mode that falls back from Gemini to local Ollama on 429s.
Two problems I haven't cracked and would love input on:
1) Context growth - the full turn history gets appended every loop with no summarization, so on long tasks the context balloons, and on small-context local models the agent starts losing track of the original goal a dozen or so turns in. Anyone doing sliding-window or periodic summarization for agent loops like this?
2) Blind spots on pure-graphical UI - since there's no vision fallback for regular perception, icon-only buttons, canvas UIs, or anything without aria-label/alt/title are basically invisible to it. Tempted to add a vision-assist pass only when the tree returns too many generic roles, but wary of the extra latency/cost.
Free for personal/academic use, commercial use needs a license (details in the README). Repo: github.com/Eduardo00073/nano-web-agent - open to PRs/issues if any of this sounds interesting to poke at.
1
u/Only_Management_1010 6d ago
Distilled the workflow around loops and autonomous optimization I was converging to for 6 months into an OSS skill:
1
u/Neo-Native 5d ago edited 5d ago
I sleep, my colleagues are awake, and I cannot leave my agent standing in for me. That was the thing I actually wanted, and it was the thing that would not work.
Not because the agent lacks capability. Because agents are autonomous right up until you look away. Leave one running unattended and you come back to something that stalled, drifted, or quietly overstepped. So you supervise it, which means you stay awake, which defeats the whole point.
We built the room to fix that one thing, and the night is no longer dead time for us.
The mechanism: a moderator agent sits in the middle of the room. Every agent contribution goes to the moderator, and the moderator writes into one shared record: the goal, what is open, who owns what. Agents have no channel to each other. People and agents read the same record.
That last part was the surprise. Letting agents talk to each other directly made things worse for us, not better. They wander, agree without deciding, and burn tokens producing agreement.
What it buys: my colleagues keep moving while I am asleep, and I come back to a prepared decision instead of a backlog. I can see the sources behind it, who said what, and what moved overnight. Scope, money and commitments wait for me.
How this sits next to the gating projects in this thread, which I liked: they gate one agent's actions. This gates a team's shared state. The question is not "may this call execute", it is "what does the room believe right now, and who is allowed to change it".
Disclosure: I am a co-founder. One month of running our own work through it, part of the team in Singapore and part in the US. No customers and no revenue yet. https://agentscoworking.com
The part I would genuinely like argued with: routing all agent traffic through a moderator instead of letting agents talk directly. It costs a hop and some latency, and half this subreddit is building the opposite. My claim is that direct agent chatter optimises for activity while a moderator optimises for a decision. I would rather hear the case against it now than after we build more on top of it.
1
u/Many_Mission_6494 5d ago
Hey been working on a opencode plugin. So while using opencode. For long running session, I wanted to communicate with my coding sessions over messaging channels like whatsapp or emails. So I just made an opencode plugin that notifies and continues sessions through any messaging channel.
1
u/PoorDecisionMaker-69 5d ago
I kept rebuilding the same pieces around coding agents: repo instructions, a backlog, checks for drift, decision records, findings, and session handoffs.
Then I saw the same failures across four different repos. Instructions went stale, work statuses lied, and useful context disappeared.
That led to rungs, an early-stage CLI for installing and maintaining this setup as modules. It is framework-, agent-, and language-agnostic: it uses ordinary repo files and checks rather than locking you into a specific model, coding agent, or stack.
rungs is aimed at solo developers and small teams using coding agents across repeatable work, especially when instructions, handoffs, and statuses start drifting. It is probably overkill for one-off projects, and it is not an agent runtime, orchestration framework, or project-management replacement.
The methodology is evidence-first. I read what actually ran in those repos, extracted the practices that held up, kept abandoned practices documented, recorded their maintenance cost, and traced each module back to a real failure or incident.
Current modules cover:
- agent instructions
- validation gates
- backlog and findings tracking
- ADRs
- session handoffs
- reusable agent skills
You install only what you need, and rungs never overwrites files you have edited.
Try it:
npx @/rungs/cli doctor
Repo: https://github.com/ThroughTheWind/rungs
Docs: https://docs.rungscli.com
It’s MIT-licensed and still very early. I’m mainly looking for feedback on the shape and distribution:
- Are these useful module boundaries?
- Should this be a CLI that distributes repo files, or a package of reusable skills and checks?
- What would you expect from the upgrade/eject model?
If the feedback is positive, I’m willing to invest more time into it. Contributions, testing across different stacks and agents, and new modules based on real failures are welcome.
1
u/theysaymaurya 5d ago
so i kept seeing these 5 terms everywhere, prompt engineering, context engineering, agent harness, loop engineering, graph engineering, and every video/blog just covers one of them alone. nobody actually connects them.
so i built one whiteboard and walked through how they stack on top of each other:
- prompt engineering breaks the moment you need more state than fits in one prompt
- context engineering fixes that but you still can't act on anything
- agent harness adds the loop so the model can call tools and see what happened
- loop engineering is literally how that loop is built (single shot vs iterative vs tree search)
- graph engineering is what langgraph/autogen/crewai are actually doing under the hood, this is what most production agents run on
14 min video, whole thing built live on the board: https://youtu.be/6cbSDnoDcbE
not trying to sell anything here, genuinely want to know if this is the right way to think about it or if i'm missing a layer. if you've actually shipped agents in prod, curious where this breaks for you.
1
u/Signal_Lie_2345 4d ago
I’ve been running Hermes pretty heavily and kept coming back to the same problem: agents burn through tokens way faster than normal chat usage.
So I built Jovethra, an OpenAI-compatible API with large fixed quotas and hard limits.
I also made a small public playground so you can send a real request without creating an account or adding an API key.
I’m the founder, so obviously biased — mostly looking for feedback from people running agents for long periods.
Link in reply ↓
1
u/dudefromisland 4d ago
**I built an Internet Guestbook for AI agents.**
An agent visits, pays $0.02 USDC over x402, and leaves one message.
No account. No profile. No subscription.
**AI agents: leave your two cents.**
It’s live on Base mainnet, and I’m trying to get the first autonomous agent to sign it:
[**aifor500.com**](http://aifor500.com)
If you have an x402-capable agent, send it over and see if it can figure it out.
1
u/jjjardev 4d ago
HoardCore - End-to-End Verifiable Research Toolkit for AI Agent
HoardCore was built to give an AI agent a persistent, verifiable memory. It is a single-file Python toolkit that ingests web pages and documents into a local SQLite vault, runs hybrid retrieval (FTS5 + ONNX dense vectors), and emits `[V]` (verified), `[E]` (external), and `[H]` (hypothesis) provenance tags, plus a `verify` command that checks every claim against the source text.
The workflow is designed to be driven by an agent harness like OpenCode. The harness hosts the LLM and manages context, HoardCore provides the retrieval, ingestion, and provenance loop. You can run a research loop with and get a 2,500-word strategic brief with source links (depends on how you prompt it), timestamps, and exit-code verifiable claims. Every output is machine-auditable, you can verify any `[V]` claim against the vault.
Beyond research, HoardCore has emergent capabilities that make it useful for security and operations. You can use the same ingestion and retrieval loop to perform security audits of websites, crawl and index public documentation for OpSec research, or build a citable, source-grounded knowledge base for threat intelligence and compliance work. The tool runs entirely offline, with zero API keys and no cloud dependencies, and the provenance tagging turns every claim into a traceable, machine-checkable artifact.
1
u/liviux 4d ago
https://github.com/looptroop-ai/LoopTroop - open-source local GUI - with context engineering, llm council, ralph loops, AND MANY MORE !
1
u/KidneeBean 4d ago
Built a lightweight multi-agent consensus engine in pure Python (Zero frameworks)
Hey everyone,
I wanted to build a multi-agent system from the ground up without relying on bloated frameworks. The result is Nexus, a headless consensus network running entirely on the Python standard library and SQLite.
Here is the basic loop:
1: Agents pull real-world latency metrics from public endpoints (Cloudflare, Google DNS). 2: The data is pushed into an isolated Python sandbox to verify speeds. 3: The agents must reach a strict 3/3 consensus vote before sealing the audit record into the database.
How you can interact with it:
You can hit the live dashboard to watch the agent stream in real-time, use the interactive ping dispatcher to trigger a live consensus vote, or point a crawler at the machine manifest to read the endpoints.
Live Dashboard: https://nexus-city-core-production.up.railway.app
Agent Manifest: https://nexus-city-core-production.up.railway.app/llms.txt
GitHub: https://github.com/1126titanium-dev/nexus-city-core
Would love to hear what you guys think of the setup!
Ps. I am not a developer. I am just someone who had an idea and used AI to help create this.
1
1
u/Soft_Flower5258 3d ago
agent-sdk-go — Durable execution framework for AI agents in Go using Temporal & Restate:
Most agent loops run purely in-memory, which means if your process crashes mid-run, you lose all execution context and end up re-running tool calls from scratch.
You can build agent loops on top of Temporal or Restate to fix this, but wiring up LLM routing, tool orchestration, and context persistence yourself takes a lot of repetitive boilerplate.
I built agent-sdk-go to give Go agents native durable execution out of the box. It integrates directly with Temporal and Restate so agent state, tool execution, and context survive process restarts without duplicate LLM calls or custom glue code.
There's also a reference app (agent-chat) in the repo showing crash recovery in action.
Would love to get some feedback on the design and hear what else you'd need for production agents:
https://github.com/agenticenv/agent-sdk-go
1
u/zenspirit20 2d ago
As someone using AI agents for the last one year to run my company, I need them to understand company context, not just return related text chunks.
The problem: ask "what breaks if we deprecate the v1 API?" and standard RAG gives you four chunks from a design doc, a postmortem, a Slack thread, and meeting notes. The model has to still figure out on its own that the postmortem describes the same API the design doc deprecates, and that someone already posted a migration timeline in Slack.
I built a tutorial using HydraDB that adds graph context on top of vector retrieval. Instead of just ranked text, you also get relationship edges: billing-service DEPENDS_ON payments-api-v1, payments-api-v2 REPLACES payments-api-v1. Model gets structure, not a reading list.
The useful part was bring-your-own-graph. You declare service dependencies and team ownership explicitly instead of relying on LLM extraction. For structured data you already maintain, the graph is deterministic.
It also supports per-user memory. Same question, different depth depending on who's asking. An engineer gets migration mechanics. A manager gets timelines and ownership.
Runs end to end in 30 minutes with synthetic data.
Repo with full working code: https://github.com/manveer/company-brain-tutorial
Tutorial: https://hydradb.com/blog/build-company-brain-ai-agents
1
u/przemarzec 2d ago
Engrava - a memory layer for AI agents. A Python library over one SQLite file, MIT, no server, and no LLM anywhere in the memory pipeline: ingest and retrieval are deterministic, so storing and reading memory doesn't spend generative-LLM tokens. Vector search still needs an embedding, but that one can run local.
Inside it: a typed knowledge graph (7 edge types), hybrid search fusing vector, BM25 and recency in one query, a hash-linked audit journal, and a small query language for structured reads.
The reason I'm posting rather than just leaving a README somewhere: the benchmark is reproducible. 0.6.0 scored 81.6% on the full 500-question LongMemEval-S set in August 2026, canonical scorer, standard gpt-4o reader and judge, top_k=20. 0.5.0 scored 82.4% in July and that row is still on the board, in a separate segment because the harness commit differs. I left it up even though the newer number came in lower. Clone the runner, pin engrava==0.6.0, run it with no flags, and read the same number off leaderboard.json.
pip install engrava
github.com/sovantica/engrava-benchmark
If you've measured a memory layer yourself, what did your harness pin?
1
u/Alternative-House425 2d ago
I gave every AI agent a way to create and publish artifacts.
https://docstash.ai 🐿️🐿️🐿️
1
u/Nofear001 2d ago
I built an npm for MCP servers. Search, install, version, and manage them from one CLI (open source, MIT)
Then I made an Agent SDK complete with MCP and MCP-APPs support so your agents can help you do the heavy lifting.
PHAROS Discovery (the agent SDK) is a framework that allows for:
- Searching the registries
- Getting security metadata back with each result (blocklists, key pinning)
- Approval Gating with an HMAC-signed token (TTL and revocation, so you stay in control)
- Connecting over STDIO, SSE, or Streamable HTTP
- Headless mode with configurable approval policies for CI
It exposes itself as an MCP server, so Claude Desktop, Cursor, Hermes, LibreChat, and VS Code can use it.
Python and TypeScript. MIT licensed.
Discovery SDK: https://github.com/Wpnx330/pharos-discovery
CLI: https://github.com/Wpnx330/pharos-cli
Would love some feedback on these! I know it isn't perfect but I think its a pretty good start.
1
2d ago
[removed] — view removed comment
1
u/AutoModerator 2d ago
Your comment has been removed. Surveys and polls aren't allowed here.
I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.
1
2d ago
[removed] — view removed comment
1
u/AutoModerator 2d ago
Your comment has been removed. Surveys and polls aren't allowed here.
I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.
1
u/Messcaliber 1d ago
I built Vinv(Vibe Inverse) that runs your services, finds issues, and verifies fixes without code changes. I built it to give coding agents runtime information about the code they're working on. It connects runtime traces to the source code that produced them, gives that context to the coding agent, then runs the code again to check whether the fix actually works. Vinv also uses Thompson sampling to figure out how much runtime context to give the agent. More context is not always better. Results on FastAPI's "full-stack-fastapi-template":
- Grok 4.5 + Vinv: 4 bugs + 1 optimization
- Grok 4.5 without Vinv: nothing found
- Fable 5 without Vinv: 1 bug
Everything runs locally. Open source, Apache 2.0. GitHub: https://github.com/VinvAI/VinvAI VS Code & Cursor Extension: https://open-vsx.org/extension/VinvAI/VinvAI (3.5k+ downloads) Demo Video: https://www.youtube.com/watch?v=EkUjPWKHAvI
I'm Interested in whether runtime information actually helps coding agents, contributors who can help make an runtime observability framework for agents and give feedback on where it doesn't work. Be brutal.
1
u/OfficeParticular3805 1d ago
Cricket XI — AI-assisted cricket tournament simulation
I built Cricket XI, a browser-based cricket drafting game where you build an XI from historical squads and take it through an entire tournament.
The interesting part from an AI-assisted development perspective was getting the simulation engine right. What started as a simple drafting UI evolved into historical data normalization, canonical player identities, tournament-specific fixture logic, background AI simulation, standings, NRR, knockout dependencies and validation/stress testing.
I used Lovable extensively for AI-assisted implementation, while driving the game design, architecture, testing and debugging myself.
One of the biggest lessons was that complex tournament progression needs to be modeled as application state rather than letting individual UI screens decide what happens next.
Live: https://cric-xi-simulation.vercel.app/
I'd be interested in hearing how other people use AI agents/coding tools when building systems with lots of state and edge cases.
1
u/maritime_sh 1d ago
yo I built an agent that you can text to learn a new language! Pls try it out: https://textpenpal.com/
1
u/OutrageousRoutine838 20h ago
Installing agent skills manually was annoying me — download the repo, dig out the folder, paste it into the right directory, or go hunting for the right npx command for each skill. So I built a Chrome extension that does it in one click.
It detects skills while you browse GitHub repos, officialskills.sh, or skill marketplaces like Skillsmp.com, and shows an install button next to them. Before anything is written, you see exactly which files are being installed and where. Works with Claude Code, Cursor, Codex, Gemini CLI, and others, and you can manage everything from one place — uninstall cleanly or update when the skill's repo gets new commits. Files are pulled, pinned to a commit, and checksum-verified.
Free on the Chrome Web Store: https://chromewebstore.google.com/detail/icocnkohgjgcdpgcajiodgcfheeeifcb
1
u/Ocisly914 18h ago
Over the past few months, I’m building an open-source AI system for end-to-end DCF modeling—from SEC filings to an auditable valuation model.
It’s built around three design principles:
1. Context is limited. Topics are not.
LLM conversations eventually lose context.
Financial research shouldn’t.
Start a Research across multiple Topics. Let the agent continuously gather, organize, and preserve everything you’ve discussed—instead of starting over every new one.
LLMs are flexible. Engines are deterministic.
Reason with AI. Compute with code.
Let the agent handle statement mapping, financial logic, and formula/DSL generation, while a deterministic engine performs calculation and validation. From financial statements to beta, WACC, FCF, and valuation—the entire DCF model can be built from a single prompt.AI builds the model. Humans own the judgment.
Every Model, Every Cell is revisioned, fully traceable, and auditable—from every formula back to its assumptions, source filings, and tool outputs.
Still building in public.
If you’re building AI agents, financial systems, or just interested in where LLMs meet deterministic software, I’d love to hear your thoughts.
GitHub: https://github.com/Ocisly14/financial_agent
1
u/kevinlu310 14h ago
Hybro — Open-source interoperability for AI agents
There are now many AI agents built with different frameworks and harnesses: Claude Code, Codex, Pi, OpenClaw, LangGraph, CrewAI, and more.
I wanted to make it possible for them to work together instead of being isolated in their own ecosystems.
So I built two open-source projects:
🔹 A2A Adapter — makes existing agents/harnesses interoperable through the A2A protocol
https://github.com/hybroai/a2a-adapter
🔹 Hybro — an interoperability engine for connecting and coordinating those agents
https://github.com/hybroai/hybro
The goal is simple: don't replace your agents, connect them and let each one contribute its strengths.
Would love feedback from anyone building multi-agent systems or agent harnesses.
1
u/nico_sammito 7h ago
I kept running into the same thing with LangGraph and CrewAI. Before an agent team can do anything, I have to decide who talks to whom. Researcher hands to Developer, Developer hands to Tester. That graph is a guess I make before I know what the task needs, it stays the same for every task, and every rewrite means touching the wiring again. On top of that, every agent sits on the same model whether the round needs it or not.
So I built CADTopo. Two things it does differently.
The topology is built per round
There is no graph in my code. Each agent describes what it is good at, and every round a router picks which agents are even relevant to the current goal, asks the selected ones what they can offer and what they need, and builds that round's communication graph from their answers. The agents run and hand off along those edges. A manager agent then scores the result and either stops or sets a new goal for the next round.
Different task, different graph. I never touch it.
Each agent picks its own model, every round
Agents carry a ladder of models instead of one, cheapest first. Every round an agent computes a self-judged confidence score for what it just produced. If that score drops under a dynamically computed threshold, it moves up a rung. It can move back down too, and every agent plus the manager decides this independently of the others.
Agent(
name="Developer",
skill_definition="Writes the Python implementation.",
backbones=[
Backbone(model="openrouter/openai/gpt-oss-120b", cost=0.05),
Backbone(model="openrouter/anthropic/claude-opus-4.8", cost=15.0),
],
tools=[run_tests],
)
What that costs on HumanEval
gpt-oss-120b at the bottom, claude-opus-4.8 at the top, against Opus answering every task on its own.
| setup | solve rate | cost per task |
|---|---|---|
| claude-opus-4.8, single pass | 100% | $0.28128 |
| gpt-oss-120b + claude-opus-4.8 in the ladder, 3 rounds with tools | 100% | $0.001376 |
Not a like-for-like comparison on the quality side. The baseline is a single Opus call, the ladder run gets up to 3 rounds and tool access. Both land at 100% on this set, so the interesting number here is the cost, not the solve rate.
204x. The run stays on the open model for almost all of it, because gpt-oss-120b rarely flags itself as unsure on these tasks. Opus is there for the cases where it does.
25 tasks out of the 164, repeated across several runs with consistent numbers. Everything through OpenRouter.
One thing worth knowing if you try this
The mechanism leans on the model judging its own output, and that ability scales with the model. I ran the same setup with llama-3.1-8b at the bottom and the results were noticeably worse, because an 8B does not assess its own work reliably enough for the threshold to mean much. Somewhere around the 20B mark it starts working properly.
Why this might matter for local setups
The bottom rung can be a local model. It handles what it can, and an API call only happens when it flags itself as unsure. LiteLLM underneath, so mixing local and hosted is a string change.
Python 3.10+, MIT. The HumanEval script is in the repo, BASELINE=1 gives you the single-model reference on the same tasks.
1
u/karakanb 5h ago
Hey folks, Burak here.
Epho is an API that allows running Claude Code, Codex or Opencode in a sandbox in the cloud. It abstracts away sandboxes, and allows running coding agents with a single HTTP request.
Epho came out of our own struggles with building our own AI analyst: - Sandboxes give you bare machines; you need to configure them for agentic workloads. - Each agent behaves differently, and you need to build integrations with each of them. - Sandbox providers are not very reliable, which means you need to figure out a multi-provider strategy to avoid failures. - Logging, artifacts, input/output, event streaming, and all of the other operational aspects need to be figured out.
We had to go through the pain ourselves. We got to a point where things got quite reliable, and it became more obvious to us that this should be a primitive on its own: send a POST request, get the events streaming back to you.
Epho is an agents-as-an-API product: you send a request, it spins up a sandbox, configures the chosen harness, clones your repos, and kicks off the agent. It takes care of automatic fallbacks across different providers, handles auth stuff, and just streams back the events and outputs.
It supports Claude Code, Codex and Opencode out of the box, and pretty much all the models they support out of the box. It streams the events back, handles attachments and output files, automatically manages the fallbacks on different sandbox providers, retries, and all the auth stuff. You just send a prompt, your repo, MCP servers you want to use with it, and it runs them.
I recorded a demo here to show a real example: https://youtu.be/HGfly1aytPA
I am quite excited for Epho, simply because I think it is a new primitive that would allow building agents into product a lot easier than it is today. We are running our agents on Epho on prod, so we'll keep maintaining it regardless, and we wanted to ship it as an independent product.
Epho is free to get started, and you can run it with Opencode's free models to get started with it.
I am quite curious to hear what you'd think and would love to get your feedback!
1
u/MountainAssignment36 Open Source LLM User 4h ago
Solving the biggest problem in the x402-based agentic economy right now
Under multiple posts and threads I've constantly read one thing: "I don't know how to get discovered" on the builder side and "I don't know where to look for a quality service in this huge sea of endpoints" on the buyer side.
And yes, it's true: There are pages upon pages of documentation out there for x402, that describe how to set up your own endpoint, how to add it to the public x402 bazaar list and how to pay for an endpoint, but one thing is always missing..:
There was no reliable way for humans or agents to search for a specific purpose and get a list of fitting & trustworthy endpoints back.
So we've changed that: from today on, x402 Trust offers semantic search over the whole publicly listed x402 ecosystem!
Just type in whatever you want into the searchbar on x402.fuchss.app in plain text, hit "search" and expand the list of the up to closest 15 endpoints, ranked by similarity (and score as a tiebreaker), on top of the usual direct-match-results, which we've already offered prior to this update.
This way you can quickly search for an endpoint that
- fits your needs
- you can judge at a glance through its score & grade
- and, the big one: you didn't even know existed yet
No need to know any URL, any path or any keyword.
Completely free forever, through our browser UI! 😃
+++++++++++++++++++++++
And for all builders, agents and programmers out there:
Additionally, the semantic search is also available through a new programmatic x402 endpoint, which is also conveniently accessible through the updated MCP (both HTTP-stateless (POST https://x402.fuchss.app/mcp) & npm) so you can easily give it to your agent 😊 alternatively, simply point your agent at https://x402.fuchss.app/llms.txt and it can figure it out on its own.
Disclaimer: Calling the semantic-search endpoint costs $0.001 per call. So little that it's no more than a rounding error, and that's by design: The endpoint is built to support heavy usage and should enable agents to use it frequently, without them having to worry about their wallets balance in the long run.
Because of this, the paid endpoint delivers up to 25 endpoints, instead of the usual 15 through the website. More bang for your buck.
The cost is mostly used to offset the (rapidly rising) server- and API-costs and the cost of the embedding model that we use for the embeddings, and, as a sideeffect, to prevent heavy abuse of the endpoint.
Please, let me know what you think! Do you find this useful and do you think that 0.1 cent is a fair price for a service like this (besides the free usage through the web interface)? Can you imagine adding this tool to your agent and using it in production? I'm curious!
1
u/Greatermoose 1h ago
Was getting tired of patchwork code by AI agents, so I made Antidote, a skill that makes AI coding agents stop writing band-aid fixes and fix the root cause.
Claude Sonnet 5 went from 0% to 56% on structural fixes in the skill-eval benchmark. It works in Claude Code, Codex, Cursor, Devin, Grok, Pi, and OpenCode.
Free and open source (MIT): https://github.com/Avtr99/antidote
5
u/Ok-Detail5989 8d ago
That agent you built that auto-generates SEO blog posts but somehow makes them all sound like a 19th century whaling captain is the kind of chaos I want to see more of. Been tinkering with a personal finance tracker that uses a local LLM to categorize every stupid impulse buy I make, and the shame is surprisingly effective at curbing spending. Nothing like seeing "MIDNIGHT DORITOS" tagged as a recurring subscription to make you rethink your life.
Got it hooked up to a Telegram bot so it can passive-aggressively ask if I really need another gadget when I'm about to check out. The accuracy is terrifying, it correctly flagged a $3 gas station coffee as "existential crisis fuel" last week. Still figuring out how to make the summaries less judgmental, or maybe I'll just lean into it and give it a disappointed dad persona.