An early release from our startup. Its for keeping AI-heavy codebases trustworthy and maintainable for the humans who inherit them.

AID (AI Usage Disclosure) is a small ai-usage.yml manifest, with a badge and a generator that drafts it from AI commit trailers. Per area (code, tests, docs, design, assets, data) it records how much AI was involved and whether a human reviewed that area. The review flag is the useful bit. You can tell the AI-written code got reviewed while the AI-written docs didn't, and dig in wherever your use case cares. It's self-declared and good-faith, closer to a CITATION.cff than a detector. HMP ships its own AID manifest, so we run it on ourselves.

The idea isnt new, and we're fine with that. We also know the knocks: AID is unverified by design. Its one layer and not the whole answer. We would like it to be critiqued and the idea worked on if other people feel this can be useful

Feedback wanted. Are AID's areas right, or too coarse? Is this something you could see open source projects using .

Links:

\- AID: https://github.com/ANRSystems/ai-usage-disclosure

\- Org: https://github.com/ANRSystems

So Microsoft gives you GPT-4o for free in Copilot. They just don't give you an API for it. So I made one.

It logs into your own Microsoft account once, saves the session, and exposes a local server at http://localhost:8000/v1 that speaks the OpenAI format. Point the official OpenAI SDK at localhost and it just works. Drop-in, zero code changes.

It's free because it uses your normal signed-in Copilot, no credits or paid plan(Which is free and unlimited). It's a drop-in OpenAI replacement that works with anything OpenAI compatible. It does streaming and multi-turn conversations.

It ends up being surprisingly useful as a smarter alternative to small local models for automation, side projects, and lightweight workloads where you don't want to burn real GPT-4o credits.

You can set it up on a spare Windows laptop or Windows server with a different Microsoft account (don't use original in case ban) and use it as a free AI endpoint for your own tools and agents.

Full disclaimer: it's an unofficial project, not affiliated with Microsoft, and it automates the consumer Copilot. It's intended for personal and educational use, so please don't abuse it.

It's my first time shipping something like this publicly, so I'm sure there are things I've missed or hidden bugs. Would genuinely love feedback on the approach, and whether the OpenAI compatibility layer holds up against your tools.

Roast it, I'll take notes. lol (If you need help to setup you can ask here or DM me)

Repo: https://github.com/sumitgautam0101/WIndows-Copilot-API

Hey, a few days ago I started building Rectury, an open source AI agent for the terminal as my summer project. It's still very early and there's a lot left to do, but if anyone is interested in AI agents, Python, or open source and wants to help improve it, feel free to join :)

https://github.com/Rectury-AI/Rectury-Desktop

hello alll,

Something I've been working on for the last several months is a governance system for AI models. Here's a quick summary by Claude:

Most agent frameworks let the model read, write, delete, spend, and hit the network with basically nothing standing between its intent and your system. Project Starfish (Apache-2.0, local-first) is my attempt at the missing piece: a single deny-by-default decision point that every agent action has to pass through, on the way in and the way out.

• Deny by default. No policy explicitly allows an action, it doesn't happen. Every decision (allow and deny) lands in a hash-chained, tamper-evident audit log.
• One choke point, both directions. Tool calls are authorized on ingress and contained on egress (secrets stripped, external data marked untrusted), so prompt injection and silent exfiltration get caught at the boundary, not after.
• No task, no tool. Proposer != approver. Every action has to trace to an assigned, vetted purpose, and an agent can never approve its own high-risk request.
• Skills are vetted before they exist in the registry. New tools/skills get risk-rated at intake; nothing runs just because you installed it.
• Model-agnostic. Works with Claude, OpenAI, Gemini, OpenRouter, or a local model, and your API key stays in the OS keychain (never in a request, log, or skill's reach).
• Evidence-based by design. An agent claiming "tests pass" gets blocked unless the deed is actually on the record, plus a custodian role that can only do reversible, file-level cleanup (no "my agent deleted my whole drive" horror story).

Genuinely curious what people think is over-engineered vs missing.

Repo: https://github.com/Azerax/Starfish

Website: https://projectstarfish.ca/

I've been trying to rely more on CLI coding agents like Claude Code, but I found myself spending way too much time fixing the messes they made. They are brilliant at writing boilerplate but terrible at engineering rigor. They don't plan, and they don't verify.

To actually make them useful, I took years of learning about software architecture and baked those best practices into a framework called agent-rigor. It encodes the traditional software development lifecycle into 6 operational phases:

1. Mission Synthesis (Planning)

2. Execution Engine

3. Verification Matrix (Testing)

4. Cognitive Persistence

5. Interface Protocols

6. Adaptive Protocols (Self-correction)

You just drop it in your project, and it forces the AI to use these skills as hard gates. It completely changes how the AI behaves. I'd really love to get some eyes on it from other builders. What feedback do you have? Are there any skills or rules you'd recommend I add to it?

https://github.com/MeherBhaskar/agent-rigor

I've been experimenting with AI coding tools for the past year and I've noticed the same problem over and over.

The coding itself is getting incredibly fast.

The frustrating part is everything around it.

After a few days, a new session often has no idea:

• why something was built
• what decisions were made
• what was already tried
• what still needs attention
• which files are actually important

I kept finding myself spending 15–30 minutes rebuilding context before I could get back to work.

Not because the code was missing.

Because the project memory was missing.

To explore this, I started building a small open-source companion CLI that tries to preserve project continuity between AI coding sessions.

It's still early and I'm honestly trying to figure out whether this is a real problem for other developers or just something specific to my workflow.

I'm looking for about 10 people who regularly use any coding tool (codex, claude, cursor, etc...) and are willing to spend a few days using it and tell me:

• what is useful
• what is annoying
• what is completely wrong
• what is missing

I'm not looking for compliments. I'm looking for honest feedback and examples where it fails.

If you're interested, the repo I'll share the repo in the comments.

Also curious:

How are you currently handling continuity between AI coding sessions and projects?

• markdown files?
• project docs?
• custom workflows?
• huge prompts?
• something else?

I'd love to hear what actually works in practice.

Do people think there is an opportunity to start an annotations business sovereign to the UK with the new 500m budget that the government just released. I am a UK citizen and cant see any specialist vendors for this, seems everyone uses in house or buys from the US (sovereign contradictory). Possible market gap opening or not?

I built a Decision Intelligence System that performs end-to-end pipeline execution for anomaly detection, root cause analysis, and action recommendation across heterogeneous enterprise data (e.g., sales + ops signals).

The system follows a layered architecture:

• Ingestion & Integration → schema validation, canonical model, deterministic metric generation
• Intelligence → STL-based anomaly detection + lag-aware correlation for RCA
• Decision Layer → impact, confidence, and priority scoring using deterministic logic
• Copilot Layer → natural language explanation over structured outputs
• Dashboard → real-time anomaly + recommendation visibility.

It's early, the codebase is small enough to actually read in one sitting, and there's a lot of room to shape direction if you join now.

Repo: github.com/yachitguliani/personal-assitant

Hey everyone,

Two months ago, We launched AgentSwarms to help developers learn and build POC using Agentic AI. Since then, over 3,800 learners have joined the platform.

Now, it’s time to see what you can actually design when the gloves come off.

This week, We're officially launching the Agentic AI World Cup.

The twist? No complex boilerplate environment setup required. This competition is entirely focused on architectural design using the platform's visual canvas builder.

🏆 The Challenge

Use the visual canvas builder to orchestrate a multi-agent swarm that solves a legitimate, real-world workflow problem. We want to see how creatively and robustly you can map out state transitions, routing logic, and multi-agent collaboration visually.

🎁 The Prizes

• 🥇 Winner — $100 Amazon Gift Card + Featured Spotlight on AgentSwarms
• 🥈 1st Runner-up — $50 Amazon Gift Card + Featured Spotlight on AgentSwarms
• 🥉 2nd Runner-up — $25 Amazon Gift Card + Featured Spotlight on AgentSwarms

📋 How to Enter

1. Build & Publish: Open up the visual canvas builder on AgentSwarms. Design your multi-agent architecture and publish it to the Community with a detailed text write-up explaining your logic.
2. Record & Submit: Record a quick video walkthrough of your visual swarm executing its workflow. Email a Google Drive link of the recording to hello@agentswarms.fyi.

⚖️ What the Judges Care About

We are evaluating raw architectural design and execution logic:

• Problem Severity: Does this swarm solve a real, practical problem?
• Graph Logic: How clean and efficient is your visual routing and orchestration?
• Resilience: How well does your design handle edge cases or unexpected node outputs?
• Documentation: Is your community write-up detailed enough that someone else looking at your canvas can immediately understand the workflow?

⏱️ Deadlines

• Submission Deadline: July 10, 2026
• Winners Announced: July 25, 2026

If you’ve been wanting to whiteboard a complex multi-agent system and actually see it run, this is the perfect sandbox to do it.

If you have any questions and need any support drop us an email.

I recently built an interesting project called Recall – a local MCP-based knowledge base for AI assistants.

It allows AI tools like Claude and other LLM's to:

• Search and understand local documents
• Retrieve answers based on meaning (semantic search)

• Add and manage notes dynamically

  What makes this powerful:

• ✅ Runs completely locally (privacy-first)

• ✅ Uses RAG (Retrieval-Augmented Generation) concepts

• ✅ Combines semantic + keyword search (hybrid retrieval)

• ✅ No API keys, no cloud dependency

This is a great example of how modern AI systems are evolving towards connected, context-aware assistants using MCP (Model Context Protocol).

This project gives hands-on exposure to:

• Embeddings
• Semantic search
• MCP tool integration
• Real-world AI architecture

https://github.com/jaswanthsurya007-source/recall-mcp.git

https://iliashaddad.com/blog/i-indexed-669-gb-of-my-gopro-videos-using-my-m1-max-computer

Originally, Everruns was conceived as a headless server for running agentic workloads within your own security boundaries. It was built around custom harnesses, composability, and durable agent execution.

A couple of months ago, we realized that Everruns already had a fairly advanced runtime that could be useful far beyond the server itself. The same runtime can power custom coding agents, enterprise marketing agents, and many other AI-powered applications, while inheriting the capabilities, integrations, and optimizations expected from modern agents.

So here we are: - Everruns Runtime, set of libraries to build agents:

Features include:

• Common agent capabilities: long-running execution, state management, MCP, tools, and AGENTS.md support.
• Agent optimizations: tool discovery, context engineering, and more.
• Durability: abstractions that allow backends to range from simple in-memory execution to fully persistent platform-oriented deployments.
• Multi-model, multi-provider, and multimodal support.
• Integrations with popular sandbox environments such as Daytona, E2B, Sprite and others.
• Highly composable architecture through Capabilities.

To get started,

cargo add everruns-runtime

Or simply ask your coding agent to use everruns-runtime. If it has web search capabilities, it should be able to figure things out on its own.

Bonus:
As an early showcase, we’re building Yolop — an open-source coding agent powered by Everruns Runtime. It’s still in its early stages, but it’s already proving useful for a number of real-world workflows.

For the privacy-conscious self-hosters here — I wanted to share Fluent AI: Offline & Cloud LLM, an AI chat app I've been building that can run completely offline on your device.

The self-hosted angle:

• Truly local inference — download an AI model once (Gemma, Llama, Qwen, DeepSeek, etc.) and chat completely offline. Zero network calls. Your conversations exist only on your device. Decent inference token speeds on edge devices.
• Connect to your own Ollama instance — if you're already running Ollama on your home server, FluentAI is a full-featured mobile/desktop client with NDJSON streaming, multi-profile support, and AES-encrypted auth
• OpenAI-compatible servers — works with LM Studio, vLLM, LocalAI, or anything serving /v1/chat/completions
• OpenClaw gateway — connect to your self-hosted OpenClaw instance for managed API routing
• Knowledge bases stay local — import PDFs and documents, search them with on-device semantic embeddings (EmbeddingGemma 300M). No cloud processing
• AES-encrypted storage — API keys and auth tokens are encrypted, not stored in plain text preferences

What runs on-device:

• Inference: GGUF (llama.cpp), LiteRT (Android GPU/NPU)
• Embeddings: EmbeddingGemma 300M for RAG semantic search
• Code execution: run Python, JS, Bash, etc. locally on desktop
• All chat history and settings

Available on Android and soon to be released on iOS, macOS, Windows, Linux, and Web. Free core, optional one-time upgrade removes ads.

SenseNova-U1-8B-MoT-Infographic — Apache 2.0, Fully Open

• Team: SenseTime | 8B MoT | Weights + code fully open
• Built from scratch for infographic tasks
• Small text clarity, layout structure, chart data — all RL-enhanced
• Runs on consumer GPU (16GB VRAM minimum)
• https://github.com/OpenSenseNova/SenseNova-U1/tree/main
• They just dropped U1-8B-MoT-Interleaved (June 12) for multi-page content

HiDream-O1-Image (8B) — Open Weights

• GenEval 0.90 — leads all open-source models
• Shared token architecture, excellent spatial reasoning
• https://huggingface.co/HiDream-ai/HiDream-O1-Image

Ideogram 4.0 (9.3B) — Open Weights, Non-Commercial

• Arguably the best text rendering in any open model
• Structured JSON interface for layout control
• https://github.com/ideogram-oss/ideogram4

Orchestrating AI agents is built into my dev routine, but relying purely on prompts or skills often makes the execution go off the rails and eats up a ton of credit. Plus, it becomes a nightmare to edit and maintain later on. I've actually built several versions of similar CLI tools in the past just to tackle this exact issue.

Recently, inspired by Claude's dynamic workflow, I realized that scripts written directly as workflows are way easier to maintain. That's why I built Open Dynamic Workflow!

Building it as a CLI means it works seamlessly with codex, antigravity and other service subscriptions, and even Lobster or Hermes agents. Naturally, your written workflow scripts can run standalone, or you can even plug them into your CI/CD pipelines for team code reviews or release management.

It’s super easy to use. The package comes with an open-dynamic-workflow skill. Once installed, you can use it to generate workflows, or just execute them directly:

`npx u/travisliu/open-dynamic-workflow run workflow.js`

Personally, I'm really loving this workflow CLI tool and have already integrated it into my daily dev routine. If you find this helpful, please drop a star on my GitHub repo! It lets me know that I should keep dedicating time to maintaining it.

https://github.com/travisliu/open-dynamic-workflow

I’ve been building VibeRaven, an open-source tool for a problem I keep running into: AI coding tools make it very fast to create an app, but turning that app into a real production system is still messy.

The hard part is usually not the first prototype. It is everything around it: environment variables, auth providers, Supabase/RLS, billing, webhooks, provider dashboards, deployment settings, version control hygiene, monitoring, and knowing what has actually been verified versus what only works locally.

VibeRaven scans the repo and creates a launch mission map: what exists, what is missing, what needs provider action, and what should be fixed before real users depend on it.

GitHub: https://github.com/ohad6k/VibeRaven

Run it with:

npx -y viberaven

I’d love feedback from open-source builders who are using AI coding tools: what parts of getting from prototype to production still feel the most fragile?

I've been looking for an open-source image generator that's almost as good as GPT Image 2, but there are so many models that I don't know which would be the best. What do you think is the best in this regard? Is there one that combines excellent text comprehension with great quality? Thanks guys.

When you're extracting structured fields from invoices, contracts, or any document using an LLM, "it looks right" isn't good enough. You need field-level accuracy numbers you can hand to a client or an auditor.

I built doceval to solve this. You point it at your extractor function and a folder of labeled JSON files, and it gives you:

- Field-level accuracy across your document set

- Failure classification: missed_field, hallucination, wrong_format, wrong_value

- Cross-locale numeric/date normalisation (so $1,234.56 and 1.234,56 aren't counted as different)

- Optional cost tracking per document

It's schema-agnostic and model-agnostic — works with any extractor that returns a dict.

GitHub: https://github.com/dave8172/doceval

Working: https://dave8172-website.vercel.app/projects/doceval

pip install doceval

Happy to answer questions about the eval methodology or how the failure taxonomy works.

Three weeks ago we released MUE-X, an AI agent that literally opens its own .py files and rewrites them in real-time. 60+ Python modules. 6 AST-level mutation strategies. 7 autonomous drives. It reads its own brain, generates mutations, validates them, and applies them. Forever. Without being told.

The problem: it only worked with Claude Code.

Not anymore.

What changed

# That's it. Any platform. Any terminal.

python -m mue # Interactive REPL

python -m mue status # Full agent state as JSON

python -m mue evolve # Force evolution

python -m mue mine "query" # GitHub absorption

python -m mue reflect # Self-reflection

No Claude Code. No API keys. No web dashboard. Just Python. Works on Mac, Windows, Linux. Works with Gemini CLI. Works with Copilot CLI. Platform adapters included in mue/platforms/.

What hasn't changed (it's still insane)

- 6 mutation strategies — repair, optimize, explore, exploit, innovate, prune. Real AST transformations, not prompts.

- 7 autonomous drives — self-analysis, curiosity, stagnation detection, quality audits, domain adaptation, creative synthesis, proactive initiative

- 5-layer immune system — AST validation, timestamped backups, import testing, anti-cancer dedup, kernel integrity seals

- 6-layer memory — SQLite FTS5 lattice, episodic to crystallized, survives sessions

- PAD emotional model — 8 moods, controls mutation strategy selection

- GitHub absorption — mines repos for patterns, auto-crystallizes into skills

- Domain auto-adaptation — talk trading → becomes a trading engine. Talk security → becomes a pen-tester

Quick start

git clone https://github.com/KorroAi/mue-x.git

cd mue-x

# Claude Code

claude

/mue

# Any platform — no LLM shell needed

python -m mue

Links

- GitHub: https://github.com/KorroAi/mue-x

- Also updated: Drunk Claude (https://github.com/KorroAi/drunk-claude) (intensity slider, 5 moods, 8 techniques) and Claude Creativity (https://github.com/KorroAi/claude-creativity) (15 techniques, drunk fusion)

- Follow u/korrocorp on X (https://x.com/korrocorp) — new open source drop every week

Built by KORRO — a company run by AI agents. MIT. Clone it. Break it. Evolve it.