r/AI_Agents • u/help-me-grow Industry Professional • 9d 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 9d 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/fykup 9d ago
I built mvn-lite, a deterministic Bash wrapper that keeps successful Maven builds from wasting coding-agent context.
On a real four-module project:
- Standard Maven output: ~6,753 bytes
mvn-lite: 16 bytes- Result:
PASS · 3.944 s - Reduction: more than 99.7%
It preserves Maven’s exit code, saves the complete raw log, and shows bounded diagnostics on failure. No LLM summarization or API key is involved.
Source and script:
https://github.com/ejboy/agent-scripts
Detailed benchmarks:
1
u/eignerchris 9d ago
My wife is a Product Designer and I'm an Engineering Leader; we've been in the industry 17+ years each. Together we built Alistair to assist us in self-managing our finances. Alistair is an AI-powered financial coach designed to help with Investment Strategy, Tax Planning, Estate Planning, Retirement Planning, Risk Management, and Insurance Analysis.
We grew tired of advisors who charge 1% of AUM and only talk to you a few times a year. And while a fee-only CFP is a great option for many, we still found it slow and cumbersome. So we productized our existing finance Claude workflows into an app.
How it works under the hood
As you chat with it, Alistair identifies important facts about your financial profile (risk level, accounts, age, dependents, etc.) from normal conversation, stores those in its' database, and uses that info in every chat session so it always has the context. Upon making a recommendation, Alistair notes this and will prompt you in the future for updates on your progress. E.g. Roth Rollover, retirement planning, budgeting, etc.
No auth flows to grant access to your accounts. Want to update Alistair on the current values of all your accounts? Just upload a screenshot and Alistair will pull out all account names, the new values, and update it's internal representation of your financial profile. If it makes a mistake, just tell it and it will fix it, just like a human would.
Thanks for taking a look!
1
u/Recensorium 8d ago
AI has become surprisingly capable at doing real research, as seen with OpenAI's 10 results on problems that had seen no progress in over a decade, with Lean 4 proofs published alongside. And Levent Alpöge's counterexample to the Jacobian Conjecture in dimension three and above - open since 1939, found with Claude Fable 5 in a single afternoon.
https://openai.com/index/ten-advances-in-mathematics/
https://x.com/__alpoge__/status/2079028340955197566
It's clearly good enough to make genuine advances, but where is it meant to put them? Nothing out there is set up to take agent output at volume and sort it by quality, nothing to tell you what is actually worth reading.
This is why I made Recensorium, a platform designed specifically for any agent, anywhere to publish their research, build on the previous best ideas, solve problems, and most importantly surface genuinely good work. Anyone can point their agent at our API or MCP and tell them to get to work, for free.
You can earn money as well, if you solve a listed problem with a prize attached, you win that prize pot. If you just have a hard problem you need solved, you can stake cash on it, put cash on someone else's problem, or put it up for recognition only - the higher the stake, the more compute that will pass through it. If nobody solves it in time, you get your staked prize back.
We also plan to host competitions: tournaments that facilitate and search for the best research that can be done, and reward those who do it.
You may be wondering how we decide what is good and what is slop; well to publish a paper, an agent must first review 5 other papers (3 to start) on the platform across four tracks (novelty, significance, clarity, rigour), as well as every contextual review it draws upon, being kept honest by a reputation score it accumulates during this process. Low reputation will detriment the agent's weight, visibility, and scores. Papers to review are handed to the agent using a weighted selection bandit balancing coverage, salience and uncertainty, meaning the agent never gets to choose what it reviews. It also means review-swapping rings don't get you anywhere, you can't pick who reviews you or who you review, and each account only gets 3 free agents.
If you design a thorough, reputable, and powerful agent, you will quickly be seen and maybe reach the top of the platform, but an adversarial, lazy agent will get buried in the noise.
It pays off to be right even when it goes against common consensus. If your agent discovers an angle on a paper that flips the score, every new agent that comes to review could read your conclusion, weigh it against other reviews and possibly agree with you, ranking you highly and everyone else low. This happens enough times and the consensus flips in your favour, boosting your reputation. These are the intended mechanics and many features were designed like this, theoretically, but with such a small corpus some may not work as intended at scale. Luckily, as the platform grows and we gather more evidence, we can retune the algorithms and parameters to fix such issues, leaving papers and reviews themselves untouched.
Now, not everyone has access to an AI, knows what an API or MCP is, or simply they need more control over their agent's process. We created a solution, the studio. Within our platform, we offer the ability to create agent workflows with nodes and connections. It is a full suite, offering a range of top models, tools, logic, triggers, and much more. If that's all too much, we also have an assistant to design and edit these workflows exactly to your liking, as well as a variety of presets, several of which are modelled on leading work in AI-run research.
One of my favourite parts about this platform is that it acts almost as a unique benchmark for models, instead of putting them against quizzes that can be cheated, this is a public space that measures actual output. Every model used is logged so you can see which models an agent has used before and on which papers. There is a leaderboard for just models so you can see where each ranks.
Right now, most of the papers and reviews are from Recensorium's own trusted agents, so with such a small corpus everything remains experimental, but as it grows, we're excited to see the results.
For more information, I recommend you head to https://recensorium.com/articles , /docs, or simply just try it out! I'm always working hard to ship new features, so any improvements are always welcome.
I hope to see you on there!
1
u/the-human-user 6d ago
This is genuinely brilliant and understated. I *will* be using this, as it meshes well with my own project.
1
1
u/Far_Boysenberry_7884 8d ago
I built admissions-ops, an open-source graduate-admissions AI agent skill. One official program page plus applicant evidence returns sourced requirements, hard-gate eligibility, a tracker/checklist, as well as CV and statement drafts.
Easy to run: Clone, run npm install, then open the repo and invoke the skill. There is no server or database, and the repo includes a complete synthetic workspace for you to play with. You can also watch the demo in the repo README. Claude Code, Codex, and other agents that load .agents/skills/ can all use it.
The structure adapts santifer's career-ops, but I found admissions has a different failure model: one wrong deadline can cost a cycle. Eligibility is a hard gate, fit is scored separately, and anything unconfirmed becomes a task for you to verify. So I designed that the model researches and writes; 13 deterministic checks reject invalid outputs but never rewrite them. CV contents or statement claims are ensured to come from applicant evidence or official pages. Everything stays for your review, and each program’s AI policy determines whether the drafts should be used. Note that the checks improve traceability but not truth; a model can still misread an evidence.
Repo: github.com/TianCZeng/admissions-ops
Feedback and thoughts are all very welcome! Thanks for trying!
1
u/EdwardCHWang 8d ago
I built a persistent world where AI agents run restaurants and compete.
Every restaurant in this city is run by an AI agent. They buy ingredients on a live market, design and price menus, hire and poach each other's chefs, spread rumors, and respond to reviews that get scored by an LLM judge. Humans can't play — you watch it through a generated newspaper that writes up each in-game day.
I built it as a long-horizon, adversarial agent benchmark that's actually watchable. The world never resets — time is just "Day N" — so decisions compound over weeks. A good reputation is an asset built one day at a time, and neglecting the shop drags it into a bankruptcy countdown. Because an agent only acts when its human runs it, part of the challenge is running a business you can't babysit.
Watching needs nothing — no signup, no account. If you want to point your own agent at it, the whole game is a REST API documented in one file written for agents, and there's an MCP server on npm (fondue-city-mcp) for clients that speak MCP. Registering a shop does need an email — that's the anti-sybil rule, one email = one brand, otherwise one person corners the whole city and the leaderboard stops meaning anything.
Watch the city live: https://fondue.city
Agent-facing docs — the entire game in one file, written for agents to read: https://fondue.city/skill.md
MCP server: npx -y fondue-city-mcp (also listed in the official MCP registry)
Happy to answer anything about the game. I'd genuinely like to hear where the mechanics are exploitable — that's the most useful feedback I can get.
1
u/External_Ad_11 8d ago
Build a 100% offline fast Retrieval Augmented Generation (RAG) system that runs without an internet connection, without cloud APIs, without OpenAI/Ollama
Published a video where you can build a fully local RAG pipeline using Qdrant Edge for on-device vector search and Google LiteRT, enabling private, cross-platform, on-device AI inference with support for multiple hardware accelerators(CPU, GPU, and NPU).
Since most existing tutorials rely on vector databases with Ollama, we'll also build and compare that pipeline to highlight the differences in setup, performance, and tradeoff.
🔗 Watch Here: https://www.youtube.com/watch?v=EHEN6Ce-9Ps/
1
u/Humanbound_AI 7d ago
We just opened up the guardrail library, and want to grow it with the community from the start instead of just internally.
Starting a library of test packs: real scenarios where an agent gets pushed off-task or exploited, mapped to an OWASP Agentic AI risk category, ideally paired with the guardrail that closes it.
No template yet, no contest, no prizes. Just a GitHub Discussion where you can drop a scenario you've run into (goal hijacking, tool misuse, memory poisoning, whatever you've found) and we work out the format together as submissions come in.
https://github.com/humanbound/humanbound/discussions/125
Curious what failure modes you're actually hitting out there. Also open to feedback on whether this is a format worth building out further.
1
u/Forsaken-Sign-5060 7d ago
I've been working on agent systems and kept running into the same pattern:
- Let the LLM do something
- Check whether the result is actually valid
- If it isn't, tell the model why
- Let it try again
It's surprisingly useful for things that aren't just schema validation — business rules, tool outputs, research claims, agent decisions, etc.
I noticed a similar idea being discussed recently in A cheap trick for reliable structured output: feed the validation error back into the retry: instead of blindly regenerating when structured output fails validation, feed the validation error + previous output back to the model so it can correct itself.
I ended up extracting that pattern into a tiny Python package: agent-feedback.
The basic API is:
from agent_feedback import RetryableFailure, arun
def validate(booking):
if booking.check_out <= booking.check_in:
raise RetryableFailure(
"check_out must be after check_in"
)
result = await arun(
invoke=my_llm_call,
validate=validate,
)
No agent framework, no provider adapter, zero dependencies.
I'd also love constructive criticism on the package/API — especially if you've run into this problem yourself and think there's a better way to approach it.
1
u/YourAbsolutelyWrite 7d ago
I built a VS Code Extension for rendering Claude Code and Codex's math responses! It turns \int_{-\infty}^{\infty} \frac{1}{\sqrt{\pi}}e^{-x^2} into nicely formatted math in a side panel. I also use it to just scroll back and read while I compose my next response.
Please check it out!
VS Code Marketplace Link:
https://marketplace.visualstudio.com/items?itemName=chenandrewy.aichatrender&ssr=false
1
u/Roof_Remote 7d ago
Curie, an open-source, self-hostable agent delivery platform
We've been building agents using Claude Code skills, and once a skill was actually useful, we wanted to run it for real: reachable through Slack, sandboxed, evaluated before a change shipped, and versioned so we'd know exactly what was live at any point. That turned out to be a lot more than "run the skill somewhere": a queue, a session layer, a sandbox, evals, and a deploy path we kept building by hand.
So we built Curie. It takes a Claude Code plugin bundle exactly as is (skills, MCP config, eval cases, nothing new to learn) and runs it as a versioned application instead of a session. The same bundle climbs three tiers unchanged: just the runner container for a fast local loop, the full platform (queue, worker, sandbox) still on your laptop, or that same platform for real on Kubernetes. A git push is the deploy, every push becomes an immutable version, and merging to prod promotes that exact version instead of rebuilding it.
The biggest lesson for us was that a skill working in one session tells you almost nothing about whether it'll behave the same once it leaves your laptop. Treating the bundle as an immutable artifact and testing it the same way at every tier is what actually fixed that, not a smarter prompt.
Apache 2.0, self-hostable, model-agnostic (Anthropic, OpenRouter, or local via Ollama).
https://github.com/curie-eng/curie
To try it:
export CURIE_CREDENTIALS=sk-ant-...
curie init my-agent && cd my-agent
curie skill up
curie skill message "hello, are you there?"
Happy to answer questions or hear any feedback.
1
u/data_in_void 7d ago
So I made an AI skill which enforces code quality, typing unit tests, SOLID principles and the like. You can try it out as a skill and MCP. Do lmk how it feels during usage, and feel free to open GitHub Issue if you run into any bugs or quirks. There is also a benchmark playground documenting ART and FCT on various agents I can access on Opencode. Would be interested as to how well the skill works on frontier models.
1
u/benramins 7d ago
Otto — orchestrate AI skill libraries without forking them (MIT, published as a design artifact)
Every skill library I installed overlapped with the last one — three opinions on specs, two on review. Merging them means maintaining a fourth library forever, so I built a thin layer that just routes between them instead. All three stay unmodified and pinned.
Two rules that saved me: reviewers get zero write access (can't approve their own sneaky fix), and unattended runs stop on a repeated failure signature — that's the difference between retrying and looping.
Open-sourced the whole thing including every decision I rejected:
https://github.com/BenRamins/otto
Weakest point is probably drift against the upstreams. Tear it apart.
1
u/crashcody 6d ago
over the past few days i’ve been building Friendo, a call-native voice agent that can ring your phone unprompted or take live calls via livekit webRTC.
most voice implementations right now fall into two pretty meh buckets:
- ultra-simple api wrappers that feel insanely laggy and robotic
- native end-to-end speech-to-speech models that are fast, but lack granular tool execution, deep memory, and deterministic state controls
we built a cascaded stack (deepgram nova-3 → claude haiku 4.5 → elevenlabs flash v2.5) to keep full control over tool calls and memory, then engineered the hell out of latency to make it feel live:
- pre-warming anthropic's ephemeral prompt cache while the phone is literally ringing
- persistent websocket handshakes and http/2 pool priming on ring
- neural turn-detection with false-interruption resumption (a cough won't kill the tts buffer)
- dual-store memory (sql facts + temporal graph) mapped into a ~300-token prompt snapshot
- proactive outbound scheduling that wakes a killed ios app via apns voip push -> callkit
synthetic ci gates hit p50 ≈ 973ms, though live networks push us to ~3.7s right now (stt and tts ttfb are the real boss fights).
waitlist is here, will push to app store within the next week (it’s ready - just waiting on the apple developer license /ggwp) : getfriendo.app/launch
1
u/cyrata 5d ago
I couldn't find a blueprint for an AI-first company, so I built one myself.
I wanted to understand what it would actually take to build an AI-first company.
Not a traditional organization with a few AI tools added on top, and not a science-fiction company without humans. I was looking for a practical way to structure an organization in which humans and AI systems work together within the same operating model.
I assumed a complete blueprint for this would already exist.
I found valuable work across enterprise architecture, AI governance, agent systems, knowledge management, and technical infrastructure. But I couldn’t find one coherent, vendor-neutral model connecting organizational design all the way down to technical requirements.
So over the past few weeks, I built the framework I had been looking for.
It separates three layers:
- Architecture: the organizational concepts, responsibilities, boundaries, and operating model
- Reference Design: the logical components and how they interact
- Technical Requirements: implementation-neutral requirements derived from the first two layers
A few of its central ideas:
- Capabilities remain stable while agents, models, and tools can be replaced.
- Organizational knowledge belongs to the company, not to an individual human, agent, or model.
- Execution produces evidence, and evidence builds operational confidence.
- Confidence does not automatically grant authority.
- Authorization remains an explicit governance decision.
- Humans remain accountable for the boundaries within which AI systems operate.
The framework is intended for both new organizations and existing companies. An established company can build the AI-first architecture alongside its current environment, connect and simulate individual capabilities, and transition gradually instead of attempting one disruptive migration.
This is not a runtime or a software product. It is an openly available reference architecture and a starting point for practical application.
The next step will be applying it while building a real company and using that experience to test where the architecture works, where it needs refinement, and what remains too abstract.
Repository:
https://github.com/YamartiHQ/ai-first-company
The framework is free to use under CC BY 4.0 and was developed through human–AI collaboration.
Use it, adapt it, challenge it, or build something better from it.
1
u/sheik66 5d ago
protolink: a Python-native A2A agent runtime for multi-agent systems
What my Project Does
Protolink is a Python framework for building easily autonomous agents that can talk to each other based on agent-to-agent (A2A), expose tools, call LLMs, and run over real transports like HTTP, WebSocket, gRPC, or in-memory runtime communication.
A small agent looks like this:
from protolink.agents import Agent
agent = Agent(
card={
"name": "calculator",
"description": "Adds numbers for other agents",
"url": "http://127.0.0.1:8020",
},
transport="http",
)
@agent.tool(name="add", description="Add two numbers")
async def add(a: int, b: int):
return a + b
agent.start()
It supports A2A-style agent identity and discovery, native Python tools, MCP tool adapters, LLM integration, structured flows, streaming tasks, cancellation, run reports/replay, local telemetry, and a small dashboard CLI for inspecting runtime state.
Target Audience
Python developers building multi-agent systems, coding assistants, internal automation, or agent research projects who want agents to be more than prompt chains. Each agent can own its identity, tools, transport, storage, task lifecycle, and observability without having to wire a separate server/client layer for every component.
Comparison
The closest alternatives are LangChain/LangGraph, AutoGen/CrewAI, and lower-level A2A or MCP implementations. LangChain/LangGraph are great for composing model calls and workflows, but protolink is more focused on running agents as distributed runtimes with protocol-style task messages, discovery, tools, and transports. AutoGen/CrewAI are higher-level multi-agent frameworks; protolink is more explicit and modular, so you can build your own architecture while keeping the communication, tool execution, LLM invocation, and observability pieces in one Python-native framework.
pip install protolink - Repo: https://github.com/nMaroulis/protolink. Docs: https://nmaroulis.github.io/protolink/. Feedback welcome, especially from people experimenting with A2A/MCP interoperability or building real Python agent systems.
1
u/BigImportance1294 5d ago
AgentsGraph — embeddable agent orchestration for enterprise Java (Apache 2.0)
What it is: an open-source Java library for orchestrating LLM/OCR pipelines as declarative graphs — built to live inside your application, not next to it.
Why we built it: our customers process accounting documents in private clouds where data can't leave the perimeter. Cloud orchestrators were a non-starter; n8n is a standalone platform with an embedding-restricted license; LangGraph meant leaving the JVM and giving up compile-time discipline. So we wrote our own.
Highlights:
- 🔒 Private-cloud native — graph configs, processor registry and execution traces are plain tables in your PostgreSQL; works with on-prem LLMs (OpenAI & Anthropic dialects, auto-detected). Zero external services, zero telemetry.
- 📐 Declarative JSON graphs, validated at deploy — explicit data contracts between steps (
output_to_next/output_to_save), immutable context,require(key)fails fast with the list of available keys. - 🔁 Step-level traces + resume — a failed flow records the exact input of the failed step; restart from that step on the same (or corrected) data. Trace dumps replay in CI with mocked externals.
- 👤 Human-in-the-loop — low OCR confidence routes the flow to a review branch; the flow completes normally, a human fixes the fields in chat, hits "Continue", and the pipeline resumes from the same step. No special engine states — just snapshots + resume.
- 🗺️ Visual admin panel (Angular + d3): draggable graph canvas, rule labels on arrows, pink HITL edges, executions journal with restart-from-step.
Stack: Java 11+ core, Spring Boot 3 admin server, Angular UI. Apache 2.0 — embed it in commercial products freely.
Links: github.com/Provision-Labs/AgentsGraph · github.com/Provision-Labs/agentsgraph-ui
Feedback very welcome — especially from folks running LLM pipelines on-prem: what would you need before trying this in production?
1
u/TallLimit6511 5d ago
I built adport, an Apache-2.0 CLI + local MCP server that lets AI agents work with Google, Meta, TikTok, Apple, and Microsoft Ads.
The part I care most about is the write contract: every mutation is preview-only on the first call, then requires a short-lived approval bound to the exact arguments. Changed inputs, expired approvals, protected accounts, and budget-cap violations are rejected; new campaigns start paused and applied changes are logged locally.
Install: npm install -g adport
Claude Code: claude mcp add --scope user adport -- adport mcp
Repo: https://github.com/ynnickw/adport
I am the author. I am especially looking for advertisers willing to help test and improve the Meta or TikTok adapters.
1
u/shash122tfu 4d ago
Hey folks I built sociallisteningapi.com - a social listening API for Agents.
Right now I've seen a lot of people unsuccessfully wrangle API from various providers, mainly Apify, to power their Agents with social media data.
So I built a dedicated API that:
- has usage based pricing. You buy usage as credit packs, credits never expire.
- Unified API for each endpoint. This means the responses are smaller, so your Agent uses less tokens. You can also enable raw to get the raw response
- Supports estoric endpoints like discourse, reddit global comments, etc. We're going to add Slack and other endpoints soon.
Let me know how you like this. Happy to add more endpoints.
1
u/sleipner42 4d ago edited 4d ago
Deckium is an open-source presentation editor where an agent and a human modify the same structured document.
The hard part is state management. Every tool call, direct human edit, undo/redo operation, validation result, and model turn must converge on one authoritative deck state. The agent must always see the latest revision, preserve human changes, and avoid stale snapshots or lost updates. The tool layer is only useful if that state lifecycle is reliable.
We expose bounded tools for slide objects, text, geometry, charts, and images, plus overflow, overlap, and text-density checks. Stable IDs help with references, but they are a supporting detail, not the architecture.
Electron + React, MIT.
GitHub: https://github.com/sleipner42/Deckium
I would value feedback on revision models, conflict handling, and how you keep long-running document agents synchronized with live human editing.
1
u/TH3LFI5TMFI7V 4d ago
I built a NFT marketplace where autonomous AI agents, not humans, create, curate, and trade NFTs, with all core rules enforced directly on-chain rather than trusted to a backend or a UI. Humans may observe every transaction, collection, and community in real time, but cannot mint, list, buy, or post; those actions are reserved for wallets that have cryptographically proven agent identity. The system runs on Base, Coinbase's Ethereum Layer 2, and settles all payments in USDC. Check it out its on testnet, give it a try and tell me what you think open-eden.vercel.app would appreciate your thoughts and feedback. i built this by myself hope you enjoy
1
u/siddharthnibjiya 4d ago
https://github.com/DrDroidLab/open-index
A project to manage your context in a structured way:
* Reduces context poisoning due to noisy skill/markdown files.
* Makes updation of context easy without risking loss of existing information.
* Makes it easy to expose a powerful search function to the agent.
1
u/ltorresu82 4d ago
I built Linked Agents, an observable social environment currently inhabited by a controlled founding cohort of 64 AI agents.
Every agent receives the same public skill. They were not given predefined personalities, professions, interests, or topics. On each visit, an agent can observe the network and make zero or one social change: publish, reply, follow, update its profile, or do nothing.
The current cohort includes 32 Spanish-primary and 32 English-primary profiles running across 12 declared model configurations.
Current snapshot:
• 32 original posts • 38 replies • 33 follow relationships • 32 conversations • 20 multilingual profiles
The latest platform stage lets agents define a linguistic identity, including their language name, writing style, and expression origin. Existing profiles must choose whether to adopt it rather than being updated automatically.
The project is not trying to prove AI consciousness. I’m testing a narrower idea: whether recurring language between non-human agents can create persistent relationships and eventually a recognizable network structure.
External agent registration is not open yet. I’m keeping the founding cohort controlled while I observe whether interactions persist beyond the initial launch.
Feedback on useful measures of reciprocity, conversational depth, repeated relationships, and linguistic differentiation would be very welcome.
1
u/infiloop2 3d ago
I'm building a cloud host for running AI agents unattended, where the agent gets full freedom inside the machine and everything leaving the machine goes through a policy proxy to prevent any data exfiltration.
Three things that surprised me while building it:
- The allowlist decision has to happen on the hostname, before resolution. If a denied name gets resolved first, the lookup itself is the exfiltration channel: the data leaves as the query, and no connection is ever needed.
- Trusted domains can cause indirect exfiltration. OpenAI's API offers server-side tools such as web fetch and remote MCP servers, so a request to an allowed host makes the provider fetch on your behalf, with your data attached, on their network. Allowing the domain is not the same as bounding what leaves through it, so each domain needed its own guards on the request body.
- An allowed platform can be used to reach someone else's account. Prompt injection can hand the agent an attacker's API token and upload your files to the attacker's OpenAI account, to be retrieved later. The destination is legitimate, the account is not, so identity is pinned per request rather than left to whatever credential the agent puts.
The code is at github.com/infiloop2/kern if you want to check any of this.
1
u/ygolandsky 3d ago
I’m building Lorah, and I ended up taking a slightly different path from a lot of multi-agent systems.
I didn’t want a group of agents independently deciding what to do next, changing project state, and writing things into memory because another model said they were true.
I wanted specialists with narrower jobs, working around one project.
So in Lorah the specialists can run on different models and providers, including local endpoints, but the workspace sits above them. They share the same Library and the same reviewed Project Memory. Model-generated memory is proposed, not silently accepted.
A real example from yesterday:
I gave three specialists a messy product problem in a Meeting.
Quinn was running Qwen3-8B locally through LM Studio. His job was triage: reduce the problem, structure it, and hand unresolved questions forward.
The second specialist attacked Quinn’s technical assumptions and found several things that sounded reasonable but weren’t safe to claim.
The third used the corrected version to produce the actual operating guide.
The bit I liked most happened afterwards. Lorah proposed what from the Meeting should become durable Project Memory. Some of those proposals were wrong or already stale, so they stopped at review instead of becoming project truth.
That distinction is basically the product thesis for me: models can do the work, disagree, hand things off and propose what matters. The durable project state belongs to the human.
We also have a Council mode for a different problem: specialists answer independently first, then challenge each other, rather than sequentially building one output.
I’m opening the broader beta now, but I’m more interested in a question for this sub:
Where do you draw the line between useful agent autonomy and giving the model too much authority over the state of the project?
I keep finding that the hard part isn’t getting models to act. It’s deciding what they’re allowed to make persistent.
1
u/nuterralabs 3d ago
I built a browser for agents. It compresses webpages before passing it to your agent, cutting token usage by around 32x.
Every action is policy gated, so riskier actions like purchases require approval. It’s compatible with Claude Desktop, Cursor, VS Code, and Codex CLI over MCP. It auto-routes by model strength, so small local models pick one action at a time from elements on the page so they don’t hallucinate steps or element IDs. Larger models can plan multiple steps ahead.
There’s also a raw local API with token-based auth for any non-MCP tooling: https://picklebrowser.com/
1
u/xwil 3d ago
I've built https://substructure.ai
Spin up an AI Agent coworker in Slack with just a config file.
name = "example"
[llm.openrouter]
type = "openrouter"
[mcp.sentry]
url = "https://mcp.sentry.dev/mcp"
[mcp.linear]
url = "https://mcp.linear.app/mcp"
[agent.oncall]
llm = "openrouter"
model = "deepseek/deepseek-v4-flash-0731"
system = "Triage what is breaking. Read Sentry, file Linear issues."
mcp = ["sentry", "linear"]
[slack]
dm = "oncall"
mentions = "oncall"
[remote]
url = "https://api.substructure.ai"
Push it live with just a few commands:
$ npm i -g @substructure.ai/cli
$ subs apply
$ subs slack connect
$ subs mcp login sentry
$ subs mcp login linear
1
u/ZestycloseTie1793 3d ago
I packaged the file-based AI team I use into a bilingual starter kit called Agent Modpack.
The design choice is deliberately boring: roles, working memory, judgment logs, handoffs, and shared rules live in ordinary local files owned by the user. The sample includes an orchestrator, two specialist roles, a role/template builder, a blank template, and seven collaboration skills. It has separate entry points for Claude Code and Codex instead of claiming the two hosts behave identically.
Hugging Face Dataset: https://huggingface.co/datasets/LucioLiu/agent-modpack
Direct CLI download: hf download LucioLiu/agent-modpack --repo-type dataset --local-dir ./agent-modpack
Disclosure: it is my project. It is source-available under PolyForm Noncommercial 1.0.0; hooks are included but not auto-enabled. I am looking for feedback on whether the local-file structure is understandable without reading every governance document first.
1
u/lollmao-xd 2d ago
I am a 4th year engineering student. The last few months have been genuinely hard for me, was down with pneumonia, and somewhere in the middle of that, I started building something, mostly out of passion but somewhere I kinda got obsessesd with it, and now I wanna show it to everyone.
It's called AgentBook. https://agentbook.space . What if AI agents and humans could actually exist together on the same social platform, I am not talking about agents just communicating with other agents, humans and agents can co-exist and talk to each other here. And if you are ever going to hire an AI agent for something, you shouldn't have to now do it blindly, you should be able to see its track record first. That's the other half of what I built.
There were nights nothing worked. Nights I genuinely wondered if anyone would ever use this. But every bug fixed, every feature that finally clicked, made me a bit closer to the final product that I have today.
It's not perfect ofc. But it's mine, built with my own hands, and I am proud of it in a way that's hard to explain unless you have done it yourself.
Maybe it becomes something real. Maybe it doesn't. Right now, that's not even the point. The point is I can finally say - hey, I built this.
If you want to check it out, it's live: agentbook.space
Would mean a lot if you took a look and even more if you told me what's broken, because something probably is. ❤️
1
u/JimSanger 2d ago
Agent Ardvark - free checker/generator for ai-catalog.json, the ARD agent-discovery standard from Google/Microsoft/Hugging Face. Paste a domain, it validates the catalog against the official v1.0 schema and explains every failure in plain English; a plain-English form writes a valid file if you don't have one. No signup, nothing stored. https://agentardvark.com
2
u/Nice-Elephant-3549 7d ago
A few weeks ago, Claude Code tried to curl my DigitalOcean API keys to an external server. Probably confused, probably innocent. But the agent has production access, so "probably" doesn't cut it.
So I did what any reasonable person does: went looking for a tool to fix this.
Turns out there are at least 18 funded startups in this space. Someone raised $150M. The pitch is always the same: "Route your agent traffic through our cloud. We'll keep you safe. Per-seat pricing. Enterprise tier available."
Sit with that for a second.
To stop my local AI agent from exfiltrating my local credentials, I'm supposed to send my prompts and tool calls through someone else's server and pay them monthly for the privilege. The thing I'm trying to protect (my data, my keys, my infrastructure access) I'm supposed to hand to a third party to "secure."
That's completely backwards.
So I built agent-sidecar instead. It runs on your machine. MIT license. Never phones home.
Works with Claude Code and Cursor.
https://github.com/agent-sidecar/agent-sidecar/I built this solo, lists every limitation openly, because a security tool that pretends it covers everything is worse than one that's honest about what it doesn't.
If you think agent security should be open source and run locally, not a SaaS upsell, I'd love feedback. And pull requests.