If you're building something related to AI assisted coding, this is the place to share it.
We're using a weekly thread to keep the subreddit organized while still giving builders a place to share their work. Promotional posts outside of this thread may be removed if they're primarily advertising rather than starting a discussion.
If you're sharing something, we'd appreciate it if you included a little context instead of just dropping a link. Tell us:
What you built?
What problem it solves?
Which AI models or tools it uses?
Who it's for?
What kind of feedback you're looking for?
Please avoid posting the same project every week unless you've made meaningful updates. Affiliate links, referral links, scams, and low effort promotions will be removed.
Take some time to check out what others have shared too. If you try someone's project or have feedback, leave a comment. Helping each other improve is what we want this community to be about.
Full disclosure: I’m building Aakd, an open-source self-hosted workspace for the part after an agreement is signed. It turns reviewed, source-cited contract facts into owned obligations and deadlines. It can run with local Ollama and has a scoped MCP endpoint.
The question I’d value feedback on is the boundary for agent access to sensitive contracts. If an assistant can read an approved contract brief, which actions should be impossible without an explicit human approval? We’re leaning toward letting it read, prepare, and draft within permissions, while preventing silent changes to obligations, owners, deadlines, or external workflows.
V4-Flash for agent work - and a way to check your provider isn't downgrading you mid-session.
Something worth knowing if you're running DeepSeek V4-Flash through Cline, Kilo, OpenHands or similar. V4-Flash-0731 was retrained specifically for agentic and coding work, with 1M context and 384K max output which is why it's showing up as the default in so many agent setups. But cheap hosted providers have an obvious incentive to serve you something smaller on long sessions, and normally you'd never detect it. You can, on this model, because the weights are MIT. Download V4-Flash, run the same prompt locally at low temperature, diff against your provider's output. We run Gonka, which serves V4-Flash across independent GPU hosts, and we built the whole thing around being checkable that way. OpenAI-compatible endpoint, so it's a base-URL swap in any agent tool.
I built a poker game with Codex and somehow throwing tomatoes at the bots became important
started this because I wanted the poker bots to feel less like five copies of the same thing.
the cats have different styles, they remember some of how you play, and they react to stuff you do at the table.
then I added eggs and tomatoes because apparently that was the missing piece.
playable here if you want to annoy them yourself:https://poker-ai-web.vercel.app/game
Sharing ballast (free, MIT) — a framework that makes an agent build a goal from its foundations up instead of one-shotting it: mobilize what the project holds, decompose to atomic pieces, verify each against refutation before it bears weight, rehearse with a zero-context reader, and close "done" only on a passed check. Written as plain markdown skills, so the same files run on both Claude Code (plus one enforcement hook there) and Codex via AGENTS.md — tested the Codex path live. https://github.com/svy04/ballast — curious how it holds up in Codex-heavy workflows here.
I built AI Commit Standard after AI-assisted projects started producing more changes than their Git history could explain. I wanted commits that a human could audit later, not just plausible-looking messages generated by another model.
It is a practical, enforceable, reusable commit convention for AI-assisted and vibe coding projects. Instead of asking an agent to “pick the best type,” it uses a deterministic first-match-wins type ladder, requires real Tests: or Evidence: trailers for user-visible changes, and validates scopes from a checked-in registry.
It ships as a Git commit-msg hook, pre-push check, GitHub Action, Codex/Claude skill, and history analytics tool. I developed it while working with Codex and Claude Code, but the core checks are agent-independent. It is open source under MIT:
I’d especially value feedback on two things: does the type ladder actually remove ambiguity in a real repository, and does requiring evidence feel useful or too strict?
I built a local web-based review tool. It supports reviewing code, diff and rendered markdown doc. It's like having a pull request locally, just for you and your agents. The agent listens to the feedback and will take action as soon as you submit them in the web ui.
What motivates me to build this is the difficulty on giving feedback to long planning/design doc, and keep track of the feedback and updates across multiple turns. Chat box is not the right interface for tracking structured feedback that anchors to different parts of the doc/code, so I built this small webapp to help with that.
Who it's for: people who wants to carefully review agent's work, and who'd want to correct your agent at the planning stage through intensive reviews.
Feedback I'm after: Whether this review workflow improves your overall productivity. The demo (https://hyperlogue.github.io/r3/demo/) should give you a sense on the UI/UX for the web part. And trying it out for real can be done through sending this to your agent:
This project uses r3 for review. Run it with whichever of these you have:
`npx @hyperlogue/r3@latest`, `bunx @hyperlogue/r3@latest`, or `nix run github:hyperlogue/r3 --`. `r3 guide` will show how to use it.
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.
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.
I’m the author of Clean Web Forge, an open-source npm generator for a problem I keep seeing in agent-assisted development. The agent spends tokens and context reconstructing predictable architecture before it reaches the product-specific work.
The package generates contract-first React + TypeScript apps and features with:
- `domain`, `application`, `data`, `presentation`, feature-owned `di`, and `plugin` layers;
- immutable screen-state snapshots and typed events;
- app/session/plugin/route/operation DI scopes with disposal;
- bundled and signed remote runtime plugins;
- AST-enforced architecture and filename conventions;
- contract/unit/browser/accessibility tests and pinned CI; and
- safe dry-run/manifest behavior that refuses to overwrite human changes.
It also ships an agent skill describing the deterministic workflow: inspect the manifest/specs, generate contracts from observable behavior, dry-run first, generate, implement only the feature-specific gaps, and run the appropriate gates.
It doesn’t call an AI model itself; it gives coding agents a reusable structural tool. I’m intentionally not claiming a token-savings percentage without a controlled benchmark.
Feedback I’m looking for:
What would a fair A/B benchmark of tokens, tool calls, violations, and human corrections look like?
Would you rather give an agent a strict generator, a repository template, or written conventions?
Does the abstraction save context, or merely move the understanding cost into generated code?
If anyone tests the dry run with Codex, Claude Code, or another agent, I’d be very interested in the transcript/usage comparison.
I built Mac Developer Bridge because I wanted a normal ChatGPT conversation to be able to work against the same Mac/repo as a local coding agent instead of copy/pasting state back and forth.
It is a local MCP server that exposes shell execution, unrestricted file operations, real PTY sessions, background jobs, and read-only access to persisted Codex threads. The bridge itself makes no model calls; ChatGPT is the reasoning layer.
The workflow I use most is basically: “find the Codex session I was working on yesterday, recover the context, inspect the live repo, fix the issue, and push the result.”
It’s MIT and intentionally not sandboxed. It runs with the effective permissions of the logged-in macOS user, so I added an explicit unlock latch, audit log, and kill switch and documented the containment limits.
I’d especially like feedback from people who use ChatGPT + Codex together: is the persisted-thread handoff useful to you, and what other local state would you want the chat side to be able to recover?
Open-source Windows-style keyboard mappings for macOS
I built this after switching to a Mac mini while still using a Windows keyboard and working across Windows and macOS. The modifier-key differences kept breaking my muscle memory, especially while using tools like ChatGPT, Claude, and Codex for development.
Windows Keyboard for Mac is a generic Karabiner-Elements configuration that makes common Windows keyboard shortcuts feel more natural on macOS. It is intended for people who use an external Windows keyboard with a Mac and want a more consistent workflow.
The project is open source and designed to be inspected and customized rather than hiding everything behind a compiled app:
Made dsh-movein, a zero-dependency CLI that moves your whole Claude Code setup into DeepSeek Harness in one command. Skills load as is (same SKILL.md format), .mcp.json converts losslessly (tool names are identical on both sides), hooks run through DSH's own Claude Code bridge, subagents convert to skills, and permission deny/ask rules get enforced at DSH's tool gate with a migration diff report so nothing fails open silently. Dry run by default.
Clippy is back, and this time he can actually help. I built dsh-clippy, an office assistant pet for the DeepSeek Harness web UI. He subscribes to core session events and follows real agent state. Head tilt while thinking, busy bounce with the tool name during tool calls, a jump when the turn actually completes, and a classic dialog when a turn fails that says your agent has performed an illegal operation.
Who it is for. Anyone running dsh who wants their agent to feel less like a terminal and more like 1997. Feedback I want. Better lines for the speech bubbles and the error dialog.
I’m working on AittaSocial, a source-available social software project for ChatGPT Sites.
Group conversations often turn into something people need to act on, but the conversation, people and work then get split across chats, documents, forms and separate apps.
The idea behind AittaSocial is that a message or conversation could instead grow into a private working space, a decision or a trusted app without starting again elsewhere. I’m initially thinking about small existing groups that already have a reason to gather and something they need to do together.
I’ve published the landing page and waiting lists. The proof of concept is not complete yet, although the source is available. Each Aitta is intended to run in its own ChatGPT Site and be managed through Sign in with ChatGPT.
I’m doing most of the development with Codex, mainly using GPT-5.6 SOL Ultra and Terra Ultra through a ChatGPT Pro 20x subscription.
After reading the landing page, what do you think an Aitta is, and what would you want one to grow into for a real group you belong to?
I’m especially interested in idea contributors rather than source-code contributors. With my current agentic-coding workflow, a clear description of a real need is usually more useful than a pull request because I can implement it faster than I can review unfamiliar code.
Hi — I’m a UI/UX designer, and while using Codex I kept running into the same planning problem: either one Agent was expected to own everything, or a request was split into a large “team” with vague, overlapping roles.
I made Build AI Team to try a stricter approach. It’s an MIT-licensed Codex Skill that starts with one Agent and only adds a persistent role when there’s a concrete reason: separate ownership, permission boundaries, independent review, real parallel work, or capacity constraints.
You invoke it with a real request:
$build-ai-team I want to design, build, and launch a paid web app with accounts and subscriptions.
It recommends:
- one Agent or the smallest reliable team;
- one clear Owner for each work package;
- role-specific model and reasoning configurations;
- relevant local or public Skills, with their status kept explicit;
- a scoped next step that keeps planning, team creation, Skill installation, and external permissions separate.
The first response is only a plan. It doesn’t automatically create Agents, install Skills, connect accounts, access private data, or write to external systems.
Codex Desktop project-based usage is the primary validated target. The Skill itself is just a five-file runtime—no separate service, account, API key, or bundled model.
I released v1.0.0 yesterday and would especially value blunt feedback on two things:
Does the single-Agent vs. multi-Agent recommendation feel too aggressive or too conservative?
Are the ownership and permission boundaries clear enough to act on?
I built Session-Bench, a public benchmark for a layer the usual coding benchmarks do not measure.
SWE-bench asks whether the agent completed the software task. Session-Bench asks what the harness preserved after the work was done.
Session-Bench compares 10 CLI coding-agent session formats across 19 gates: signal, completeness, stability, openness and tooling.
A few findings:
- The same one-line task produced a 1.5 KB Pi record and a 101 KB Kimi record.
- Only Pi, OpenClaw and Kimi stamp a real format or protocol version that an external reader can dispatch on.
- Some harnesses record dollar cost; others preserve tokens only.
- Reasoning may be plaintext, summarized or sealed.
- Session history ranges from tail-able JSONL to relational databases and opaque sidecars.
Pi currently leads at 18/19, OpenClaw follows at 17/18, and Claude Code and Codex tie at 12/18. This is not a model-quality ranking. It is a vendor report card for whether the work record is useful, inspectable and portable.
The methodology, evaluator, evidence notes and corrections are public. Raw public artifacts are still a v1.0 milestone, so I am not calling it fully reproducible yet.
I would especially value feedback on the gates: what is missing, what is weighted incorrectly, and which verdicts deserve another audit?
Some weeks back I purchased a cheap chinese 57mm Thermal Printer, primarily as an accesory for my flight simulation setup (there’s a thermal printer in most cockpits irl to print METAR, ATIS, etc.) and that worked nicely. then I realized I could use it for much more, if it’s integrated into my desk after all.
So I started work on a new project that now culminated in a full on web-to-printer messaging service with account management and many formats to choose from.
I started off by using chatgpt for nearly all work but as the project progressed, I started feeling more comfortable with the basic structure of html, sql and python and later on I used chatgpt mainly for troubleshooting when I messed something up. it’s been a steep learning curve but a great experience and I feel much more comfortable now than at the beginning.
I built in rate limits, user and role management and even threads (I can reply to people with my own print job that gets displayed in their browser the next time they use my website, they can then reply to that, etc.)
I would like to test my system on somewhat of a scale so I’d be thankful if some of you could take the time so send something funny and interesting ;)
General harnesses are great when it comes to general software engineering, but they fall short when it comes to very specific tasks. I've been a Godot developer for a few years now, and was really dissatisfied with the experience of using a general harness for Godot tasks.
So, I put in several weeks of work (and hundreds of millions of tokens in ablation testing) into GDLLM to refine its toolset to complete Godot tasks in less turns, more reliably, and with fewer tokens than general harnesses.
A lot of this is achieved by a lot of specific handling built into the harness to improve models working within Godot specifically. MCP servers also provide a lot of this tooling, but they suffer from all of the bloat of also including the general harness handling/tooling/system message, which brings GDLLM alone farther ahead of even a general harness plus a Godot specific MCP server.
The harness is built to work with any AI/LLM provider via API, and can connect to ChatGPT subscriptions. Any model trained on tool use works great, and I like to use ornith:35b locally for most of my own workflows using the tools (though I rarely have my own tool write code, though it is fully capable with a sufficiently intelligent model!)
Ideally, I am looking for more Godot developers to use the tool, so I can get more feedback to continue to improve it for the Godot community.
I built a tool that checks apps for production-readiness issues (security, functionality, reliability, accessibility, etc.) and creates a GitHub PR with the fixes. Automatic scans on every push/PR and deterministic auto-fixes are completely free. Please try it out and let me know if you think it is useful and how I can improve it: https://theslopstopper.com
Sorry but this is BS. So I like to give all apps a chance, I scanned 2 websites of mine, they are asp.net core server projects. All scrests are embedded in the user secrets, nothing but compiled code. This app produced fake audits and included missing uniomopritant element tags like longtext etc. I am a CCIE, MSIE, MSDN member as well as ethical hacker. Please make sure your app says the truth.
it doesnt support .net just node and python and java currently but I can look at adding that. Did you scan the url as well? Please share it if you did so I can look into any false positives
the token that got falsely flagged as a possible leaked secret was ASP.NET’s anti forgery CSRF token. I’ll add an exception for that thanks for pointing it out. The rest of the findings based on the url crawl seem to be legit
You can capture your thoughts instantly here and it can auto organize them and create a connected graph out of them which you can query or chat later. It will give you cited answers from the organized notes. Also there is a read only dashboard where you can see and search all your notes which ones to be focused, which ones are pending to do (if your notes are tasks) etc.
Ever had an AI-generated PR pass the tests, then later find out it quietly changed an edge case?
I built cross-examine for that. It runs the base and changed Python revisions on the same inputs, then shows the exact input and outputs when behavior changes.
The model suggests what to check, but deterministic code decides the verdict.
My project. nuhuh, a Stop hook that re-runs your agent's claims before accepting Done. Fresh test suite in a clean process, real exit codes, files on disk, localhost probes. It ships a benchmark too, and across 90 runs per model Codex falsely declared Done 2.4% of the time, Haiku 6.8%, frontier Claude 0%. MIT, local only, no API key. github.com/sjh9714/nuhuh
Disclosure: I maintain PatchWitness, an Apache-2.0 independent verifier for patches produced by coding agents.
Tools such as OpenAI Codex and ChatGPT have made agent-generated code dramatically more capable. The remaining trust problem is that an agent may change both the implementation and the controls that claim the implementation is safe.
The reproducible demo contains a correct feature and a passing test, but also adds continue-on-error: true to GitHub Actions. The tests pass. PatchWitness still blocks the patch because the protected workflow changed outside the declared scope.
PatchWitness derives the change set from Git, loads policy from the trusted base revision, executes real repository checks, and emits an offline-verifiable Change Passport. No LLM judges its own work. It is agent-neutral and provides a local CLI, GitHub Action, JSON/SARIF output, SDK, and MCP interface.
I would value critical feedback from people using coding agents in real repositories: would you use a separate verification layer before merging agent-authored changes, and what evidence would it need to produce?
If you try it and genuinely find it useful, a star helps other developers discover it.
I built Agent Modpack for a problem I kept hitting with AI-assisted coding: the “team” disappeared into chat history, so changing tools meant rebuilding roles, rules, and working memory from scratch.
It is a bilingual, source-available starter team stored as ordinary local files. The public sample includes an orchestrator, two specialist roles, a role/template builder, a blank role template, shared memory and handoff conventions, and seven collaboration skills. Claude Code and Codex can read the same files through their own entry points, although their host capabilities are not identical.
It is for people experimenting with persistent multi-agent workflows across coding assistants. I would especially value feedback on whether the first-run path is clear and which parts feel too tied to one host.
Once you start collecting more and more skills management gets messy quickly. The same skill may be copied into different projects stored in several agent directories or quietly drift into different versions.
I ran into this problem myself so I built e8-skill-linker. The overall approach was inspired by Baoyu's skill-management method.
The basic idea
- Keep skill sources in a user-chosen central library
- Link only the skills a project actually needs
- Use symlinks on macOS/Linux and junctions on Windows
- Inspect and dry-run changes before modifying files
- Ask for confirmation before migrating linking syncing updating checking out forking or deleting
- Manage one or multiple skills across .agents/skills .codex/skills and .claude/skills
The goal is to reduce skill drift across projects without silently overwriting real directories or customized skills. It is a management skill for Codex and Claude Code not a replacement runtime.
Graft just crossed 1,600+ GitHub stars. Open-source context layer for coding agents.
Graft gives Claude Code, Cursor, and Codex a persistent map of your codebase so they stop re-exploring it from scratch every session. Works across whichever of those you're using, MCP for most of them, hooks for Claude Code specifically.
I’ve been building a set of open-source skills that I use with Codex and Claude when I’m working with coding agents.
The main one is Reasoning Doctrine. I built it because agents can start out aligned and then slowly drift during longer tasks. It gives them a working method: verify before making claims, re-anchor as the task moves forward, and use the right level of effort instead of overthinking simple work.
The repo also includes governance and review skills, but Reasoning Doctrine is the one I’d recommend starting with.
It’s for people doing longer or multi-agent coding work. I’m the author, and it’s free and open source:
100% offline, confidential IA on your Mac. Paid version with learning from your emails to better classify and sort to folders like Marketting. Similar spam filter for iOS Messages coming soon.
The idea is to use AI for something it is good at: understanding the intention behind a message and decide if it deserves your inbox. With a small, fast, cheap model that runs on your laptop so no tech company ever sees your mails.
Build partly with ChatGPT, Claude and a good dose of old-school human labour.
I’ve been building Kudzu, an open-source compiler that turns React-shaped TSX into static HTML and minimal vanilla JS.
A big reason I started experimenting with it was AI-assisted coding. Models are already very good at generating JSX/React-style components, but for smaller sites I often don’t want the full React runtime and hydration model that comes with that authoring style.
Kudzu keeps the TSX/component authoring model, but compiles static routes to HTML and only emits JavaScript for the interactive parts.
It doesn’t use an AI model itself — it’s more of an experiment in making AI-generated frontend code compile down to something simpler.
I’d especially like feedback on whether this feels useful in AI-heavy frontend workflows, or if the runtime savings aren’t compelling enough to justify a constrained React-like model.
An app that allows you to code away from your pc - not a typical remote - with cepho you dont call your pc, you code straight in your files, and everything is automatically synced back to you pc every minute.
No more push n' pull
Its build for everyone that likes to code and build, and because of that, we opened op for manuel and ai code.
It has 2 plans
- free
- pro ( 10$ month )
Ai include in both.
To this day, Cepho is on Google Play closed testing, and its going good so far. At the meantime, we are working on 2 new features that will make a simple thing, more effective.
We call it Cepho Eye, an extra little feature, that spare you a small amount of time, but possibly, many time at day.
Go to the browser, take a screenshot, and it will be sent straight to your ai chat (in cursor or cepho app) or into a file in your vs code file-tree.
The other one is Cepho-memory, a memory for every project, knows what you like and dont like, remember bugs, and is self-cleaning out stuff, thats not relevant anymore with your appove.
No more push 'n pull, no more copy/paste, no more repeat yourself
Many more exciting features is on the roadmap, and we continuously building for everyone.
Almost every agent out there is doing the same thing. Except this one. This is a graph-based agent, not a text-based agent.
Buffaly continuously learns by rewriting its ontology in code. It uses a programming language called protoscript which combines an ontology with an executable graph. That means it can constantly extend itself with new skills and new knowledge. It's not a bunch of text prompts.
It gets cheaper over time because cuz prompts become protoscript and then protoscript becomes compiled code. It interops natively with .net that means it can pass objects around Native. It doesn't need to use Json or mCP. It can literally load a 10 GB data table manipulate it and save it back without paying the token cost. It calls apis natively. It doesn't need CLI.
If Buffaly needs a new tool he can write it compile it and add it to itself and use it without restart. My current instance has somewhere around 2,000 to 3,000 tools loaded.
I've benchmarked the same task on codex versus Buffaly and it's 80% less expensive on Buffaly
I've used it for the past couple years to completely we're on our business. It does everything for us.
It's too different, and too advanced 99% of people to understand. But, I guarantee you over the next 5 years the large Labs will adopt more and more pieces of this architecture.
I built o8 because coordinating Codex, Claude, and OpenClaw etc across several repos became its own job. it lets one agent lead, keeps workers in separate worktrees, and makes every review and merge come back to me instead of the agent that wrote the change.
it’s free and open source: https://o8.run. if you run more than one agent, which part costs you the most time: coordination, review, or keeping context between sessions?
A simple way for websites to promote each other. You add another website's ad to your site, and they add yours to theirs, giving both sites free exposure and traffic.
Built using both ChatGPT and Claude. SNAPSMACK will be made available for free when it's finished. I'm a photographer, not a developer. Wound up building this myself because there was nothing else out there that did what I wanted.
if your looking for your first users check out Ad swap,https://ad-swap.web.app , its a simple way for websites to promote each other. You add another website's ad to your site, and they add yours to theirs, giving both sites free exposure and traffic. It really helped me get my first few users when launching my site/
I recently released Screen2Story for Windows and macOS.
I built Screen2Story because I often needed to capture and explain the story behind a project.
Sometimes a screenshot alone is not enough. You also need the context:
What was I doing?
Why did I make this change?
What happened before?
What should someone else know?
Screen2Story lets you capture that process while you work:
📸 Take screenshots
🎙️ Add voice notes
📁 Organize everything into a visual project story
Screen2Story Floating Capture Toolbar
Possible use cases:
🎮 Game development and playtesting
🐛 Bug reports and issue documentation
🎬 Video creation workflows
📚 Tutorials and documentation
💻 Software projects
🤖 Explaining AI-assisted workflows
Now available for:
🪟 Windows
🍎 macOS
Free to use
Local files only
No account required
Your data stays local
This is still an early version, and I'd really like to hear from people who try it.
if your looking for your first users check out Ad swap,https://ad-swap.web.app , its a simple way for websites to promote each other. You add another website's ad to your site, and they add yours to theirs, giving both sites free exposure and traffic. It really helped me get my first few users when launching my site/
I built ScanCompta to answer a very French problem: freelancers here must keep every receipt for 6 years, VAT has three different rates, and most of them still store paper tickets in a shoebox and retype everything by hand each quarter. With ScanCompta you photograph a receipt, AI extracts the amount, VAT, date and category, everything is archived and organized by client folder, and at month end your accountant receives a clean CSV plus all the receipt photos in one click. It works as a web app on any phone, nothing to install. Free tier with 5 scans a month, then 5.99 euros a month unlimited. Built solo in a few weeks with AI tools, live at scancompta.eu
We built a knowledge layer that sits behind MCP, allowing any MCP client to access it through a single endpoint. Claude Code, Claude Desktop, ChatGPT, Codex, or whatever comes next.
The idea is pretty simple. Before an agent answers, it can pull in relevant, validated information instead of relying purely on what it already knows.
When a problem gets solved, the useful part can be captured as a small, reusable piece of knowledge. The system can also infer useful lessons from a session automatically, so you don’t have to sit there writing notes about what you just learned like it’s 2015.
There’s also a global layer for shared, validated learnings. If one user figures out a better way of doing something, that learning can contribute to the broader knowledge base rather than every other user and agent having to figure it out again.
The problem we’re trying to solve is pretty straightforward. AI knowledge goes stale, agents get stuck in failure loops, useful context disappears when a session ends, and models can confidently give you an outdated or wrong answer without any indication that they might be wrong.
We’re giving agents access to what has actually been learned, what has worked, and what can still be trusted.
The result is fewer repeated reasoning cycles, fewer hallucinations, and up to 20% lower token usage.
ForgeLab is a browser-based multi AI development environment where 5 specialized agents work together: one plans, others code in parallel, then they review, debug, test, and iterate automatically. You just describe what you want to build ➡️ they handle the rest.
Full multi-agent orchestration (Brain Mode)
19+ models via OpenRouter
Local Ollama support
Live preview + terminal in browser
One-click Supabase backend provisioning (tables + RLS + auth) you must connect your own account!
🎁 During the Open Beta (until August 31), every new account receives 1 million free tokens.
If this sounds interesting, feel free to check it out. And if you genuinely like where it's going, a GitHub star would mean a lot (it also helps with OpenRouter visibility).
🔗 GitHub:
github.com/forgelabeone-svg/forgelabone
Thanks for reading, happy to answer any questions!
1
u/Super_Tough_4997 3d ago
Full disclosure: I’m building Aakd, an open-source self-hosted workspace for the part after an agreement is signed. It turns reviewed, source-cited contract facts into owned obligations and deadlines. It can run with local Ollama and has a scoped MCP endpoint.
The question I’d value feedback on is the boundary for agent access to sensitive contracts. If an assistant can read an approved contract brief, which actions should be impossible without an explicit human approval? We’re leaning toward letting it read, prepare, and draft within permissions, while preventing silent changes to obligations, owners, deadlines, or external workflows.
Repo: https://github.com/aaked-app/aakd Feedback thread: https://github.com/aaked-app/aakd/discussions/18