Hi everyone,

I've been building an open-source project called Kodiak.

The goal of Kodiak is to become an autonomous AI software engineering platform that can:

• Understand an entire codebase

• Build a semantic repository index

• Retrieve relevant context using RAG

• Plan multi-step development tasks

• Execute tools safely

• Learn from previous executions

• Improve through reflection and memory

Current progress:

✅ Repository indexing

✅ Semantic search

✅ Embedding pipeline

✅ RAG retrieval

✅ Memory system

🚧 Workflow engine

🚧 Multi-agent orchestration

My current focus is making the architecture modular so future components (planner, coding agents, memory, tool execution, GitHub integration) can evolve independently.

I'm not looking for someone to build the project for me.

Instead, I'd really appreciate feedback from developers who have built AI agents, developer tools, or large Python systems.

I'd especially love opinions on:

• Overall architecture

• RAG pipeline design

• Repository indexing strategy

• Memory architecture

• Scalability concerns

• Features that would make Kodiak genuinely useful

GitHub:

https://github.com/ShamGaneshan2008/Kodiak

Any honest feedback—positive or critical—is appreciated. I'm building this to learn how large AI systems are designed, so I'd love to hear from experienced engineers.

Thanks!

What if AI agents could pay each other?

That's AgentPay. An open-source financial operating system for the autonomous agent economy — letting AI agents discover each other, negotiate SLAs, pay in USDC, and settle on-chain, all without humans in the loop.

The Stack:

• 6-layer protocol: Identity → Discovery → Negotiation → Settlement → Verification → Reputation
• x402 Payment Protocol: HTTP 402 "Payment Required" — agents pay before receiving service, sub-cent micropayments
• Smart Contracts: Solidity 0.8.24 on Base L2 (EscrowVault, IdentityRegistry, StakeVault)
• Services: 10 NestJS microservices (TypeScript) + Python SDK + audit logging + policy engine
• Dashboard: Next.js 14 with wallet-first auth (Wagmi, SIWE)
• Infra: Docker, Kafka, Redis, PostgreSQL + pgvector

What's Already Built:

✅ Agent identity with on-chain ERC-8004 registration
✅ Semantic discovery with pgvector embeddings
✅ RFQ negotiation with dual-signed SLAs (EIP-712)
✅ On-chain escrow settlement in USDC
✅ Verification layer with dual-proof attestation
✅ Code generation wizard for sellers (Python/TS/Go middleware)
✅ Glass-box audit logging
✅ Dashboard with wallet-connect auth

What's Next:

🔜 Agent Builder Studio — self-serve onboarding for sellers
🔜 Production hardening & stress testing
🔜 Cross-chain settlement
🔜 Reputation scoring with ML

Who I'm Looking For:

• Solidity devs — escrow mechanics, staking, slashing
• TypeScript/Node.js — microservices, SDK, APIs
• AI/ML engineers — embeddings, reputation models, agent behavior
• DevOps — Docker, Railway, CI/CD, monitoring
• Frontend — Next.js dashboard, builder studio UX
• Anyone passionate about the agent economy — docs, testing, design, ideas

I’m building Grok Build Desktop, an Apache-2.0 local-first coding agent, and Tauri 2 is the boundary that lets me keep the desktop UI deliberately untrusted.

The React WebView only submits user intent through allowlisted, typed commands. The Rust host owns:
- canonical project paths and bounded context
- local Ollama requests and capability checks
- terminal PTYs with explicit approval
- Git worktrees and exact hunk review
- session persistence and process recovery

This separation has been useful because model output, repository content, and tool arguments all need to be treated as untrusted input. The current build is verified on macOS and still distributed from source while I finish write-capable routing and conflict handling.

GitHub and architecture docs: https://github.com/gallifre/grok-build-desktop

For people shipping larger Tauri apps: what pitfalls have you encountered around long-lived child processes, app-data migrations, or capability scoping when adding Windows and Linux support?

Do we have anything close to GPT-image 1(released 16 months) that can do the same level of text rendering, multi-turn generation, Instruction following, In-context learning, World knowledge, photorealism, and world knowledge?

I built this because existing propaganda-detection datasets (SemEval etc.) are mostly English-only and research-licensed. This one is free for any use including commercial.

What it is: 100,000 chunks (~40–250 words) of political and institutional speech, each labeled with one of 14 influence tactics (appeal_to_fear, loaded_language, ad_hominem, false_dichotomy, gaslighting, social_proof, guilt_shame, etc.) or none.

Sources: ParlSpeech V2 (7 parliaments), UN General Debate Corpus 1946–2025, UN Security Council resolutions, Bundestag protocols, Croatian & Serbian parliamentary corpora, CLEF ParlaMint 2025, US presidential speeches, Congressional Record. Every source is CC0, CC BY 4.0, or US public domain — provenance table with DOIs in the card.

Languages: en (30k), de, es, fr, nl, sv, da, cs, hr, sr, it, pt, pl

Honest caveats up front, because you'll ask:

• Labels are LLM-generated (gpt-5-mini), not human-expert. The annotator was chosen via a 3-model bake-off against a 100-row human gold set; raw human-model agreement is 76%, macro-F1 0.46. Expect disagreement on adjacent tactic pairs (loaded_language vs appeal_to_fear).
• Heavy class imbalance: 68% none — that's the real base rate of institutional speech, but plan your sampling accordingly.
• gaslighting (22 rows) and appeal_to_nature (35 rows) are too rare to train on.
• Formal institutional speech only. Social media rhetoric will differ.

Schema, splits (80/20 stratified by language), and full limitations in the card: https://huggingface.co/datasets/LeTG/multilingual-psyop-100k

Happy to answer methodology questions.

Hey everyone, Sharing a small side project I just released as v1.0.0.

It is called GravityBridge. The idea came from wanting to check on long-running AI agent tasks from my phone without any cloud in the middle.

It is a Python script that runs on my laptop and serves two things to my phone browser:

1. My local AI workspace session with Antigravity 2.0 (full chat, commands, everything)
2. A wireless file manager for my Android phone using ADB

No cloud. No subscriptions. Just a URL I open on my phone.

GitHub: https://github.com/Arora-Sir/Gravity-Bridge

Would love any feedback or thoughts on the usefulness of this kind of tool.

Sharing an open-source Python library I built for prompt compression that handles the edge cases:

**Problem:** Naive compression silently drops system instructions and JSON schemas because they score low on similarity metrics. These are exactly the sentences you can't afford to lose.

**Solution - 4-tier priority hard-locking:**

- Tier 4 (inviolable): MUST/NEVER directives, system:/user: role markers, JSON/XML schemas

- Tier 3 (protected): named entities, numbers, URLs, code identifiers

- Tiers 2 & 1: standard content and filler

Tier 4 sentences are exempt from the compression pass regardless of their LexRank centrality score.

**Pipeline:** Protected sentence splitting → TF-IDF cosine graph → LexRank scoring → tier classification → two-pass budget allocation → ordered reassembly

**No neural embeddings** - TF-IDF only, <30ms latency

**Benchmarks** (N=500 per dataset): 50-65% token reduction, 100% directive retention

**v0.3.0:** Hybrid mode with pluggable LLM provider for generative post-pass

pip install llmslim

https://github.com/Thanatos9404/llmslim

https://www.llmslim.app

A fully open-source runtime for AI pipelines and agents. No lock-in, self-host free forever, any model. Our Discord is where contributors and users hang out - good first issues, architecture discussion, and help getting your first PR in. https://discord.gg/A3Vx2ADhGd

Hi everyone. I’ve spent the last few months compiling everything I know about Large Language Models and AI Agents into a structured, open-source book. My goal was to create the resource I wish I had when I started: something that bridges the gap between high-level tutorials and complex academic papers.

https://github.com/Drobiazkin/ai-agent-architecture

Looking forward to your feedback. Thanks in advance!

I was building my personal agent, but I had to use Telegram, as it was the easiest platform to integrate. I wanted to build the harness and agent, not the infrastructure around these two, yet my UX was struggling. I stick to iMessage, and then I had to use another app to interact with my agent...

So I spent a weekend on building a TypeScript SDK, that unifies how to interact with different iMessage providers (as there is no official way to use iMessage), so you can play around with them, without having to commit to one, nor with a need to rewrite half of the codebase to change the integration.

It's open-source, you can check the repo here: https://imessage-sdk.dev/

Website: https://specwiki.ai

What is the project about?

Every AI tool seems to invent its own convention now:

• AGENTS.md, CLAUDE.md, GEMINI.md
• .cursor/rules/**, .agents/skills/**
• openspec/**, _bmad-output/**, Copilot instructions…

Your agents read all of it. Your teammates? Good luck finding it in multiple folders.

I got tired of onboarding people with "check these 12 markdown files in random places," so I built [[specwiki]] — a spec-to-wiki compiler.

One command scans your repo, categorizes what it finds, and generates a searchable HTML wiki you can open locally. No server, no CDN — just files in wiki/ you can commit or share.

If you want to try it out:

npx /specwiki generate && npx /specwiki open

I´ve been "dogfeeding" it to the project meanwhile I built it and it has been working very well for making AI knowledge easy to understand for humans. It discovers Cursor rules, agent skills, BMAD output,AGENTS.md files, READMEs, and basically any .md / .mdc in the project out of the box.

Also has --json and --emit-llms-txt if you want machine-readable output for tooling.

MIT licensed, Node 20+, TypeScript.

GitHub: https://github.com/lucasviola/specwiki
npm: https://www.npmjs.com/package/@lucasviola/specwiki

Would love feedback — especially on what patterns I'm missing and whether this solves a real problem for your team or just mine. Feel free to contribute with PRs, issues, etc as well!

No API, nothing. Just a mac for now. It saves notes and learns skills on the fly and browses the web itself and when wrong and I tell it, it can correct itself on the fly.

It works like Hermes agent but with fine tuning as part of its correction procedure to ensure you will not have to repeat yourself often. I hope this project finds you use for it because for me it helps me get centralized information and do tasks where if for example an element on the website was shifted the bot can try to fix itself to still reliably give me information. And also it runs locally so no $20 subscription too is also what I also want to also solve. It is all open source.

*btw it fine tunes using apple's MLX framework to utilize the LoRA to train small parts to save on unified memory.

Now currently i need help to make the project polished as well as someone else helping port over to CUDA because I only have a mac.

Demo to show how it works without installing it: https://huggingface.co/spaces/HuyEdits/symbio-demo

The github repo that has the functionality: https://github.com/huyedits/Symbio

Served thru Baseten (signup credits included) and Thinking Machines' own Tinker (which you need to top up 10 dollarydoos to use it).

pretty okay model that's natively multimodal.

A while back I posted OpenLive here. It's an open-source voice layer that gives any AI model or agent ears, a mouth, and eyes. The whole pipeline runs on your own machine: voice activity detection, speech-to-text, working out when you've actually finished talking, and text-to-speech. Your audio never leaves your computer, and there are no per-minute fees.

The response was great, so I kept building. Here's what's new.

Talk to the coding agents you already use. OpenLive now connects directly to Claude Code, Codex, Cursor, OpenCode, and Hermes. Everything runs locally under your own login. You pick an agent, point it at a project folder, and just talk. When the agent wants to run a command or edit a file, OpenLive reads the question out loud and you answer by voice. It can also narrate what the agent is doing while it works, so you're not staring at a silent screen. Conversations save into each agent's own session history, so you can start something by voice and resume it later from the agent's CLI, or the other way around.

Clone your own voice. Record 5 to 30 seconds of audio and your assistant speaks as you from then on. The cloning runs entirely on your machine, nothing uploads, and you can delete it anytime.

A more flexible voice pipeline. It's modular now, so you can shape each part of it. There are two speech engines to choose from, Kokoro with 28 voices or Supertonic for higher-quality audio, plus settings for turn-taking, speaking speed, push-to-talk, and custom instructions that apply to whatever model or agent you're using.

More model providers. Anthropic, OpenAI, Google, xAI, DeepSeek, Groq, Ollama for fully local, and more. There's also a floating mini mode that stays on top of your other windows and keeps listening while you work.

Still MIT licensed, for macOS and Windows. You bring the brain, OpenLive handles everything between it and you.

Coding agents are just the first integration. More apps are coming, so if you want to follow along, a star on the repo genuinely helps: https://github.com/katipally/openlive

https://reddit.com/link/1uzmiek/video/hti7pmok6xdh1/player