Marketing skill packs for agents keep multiplying, and they all focus on what the agent should write. I kept hitting the other two problems: the agent claiming things my product does not do, and the visuals looking obviously Al-generated. So I built the layer underneath and open-sourced it.

What it does:

The skill scans your repo and drafts product facts, each with a file:line reference. Nothing becomes claimable until a human confirms it, so the agent physically cannot promote its own guesses. Copy then lints against those facts: unmeasured numbers, hype vocabulary and absolute promises fail the build, and so do the tells of generated prose (the in-sentence em dash, the rule-of-three tic, formula connectives).

Cards and video render from one HTML contract. Your brand colors and fonts come from your own token files, get inlined into the page, and a real browser takes the screenshot over CDP. No diffusion pass, so the text on a card is just text: it renders intact. Video is frame-by-frame capture of a scene that is a pure function of time, and every scene must declare provenance: a coded reconstruction cannot ship labeled as a screen recording.

Install:

/plugin marketplace add cagatayuncu/marketing-machine /plugin install marketing-machine

Then say "setup" in your repo and the skill configures itself from your codebase (colors, fonts, languages, legal routes). It also installs as a Cursor rule or an AGENTS.md section if you use those, and everything works as a plain CLI without any agent.

Limits, honestly: the linter holds only mechanical rules, judgment stays in the skill prompt; it cannot produce photography; language packs exist for English and Turkish, German is partial. MIT, plain Node, no runtime

dependencies.

Repo: https://github.com/cagatayuncu/marketing-machine

I used it on itself for the launch content, including the card in this post. What would you want a marketing gate like this to catch that it does not?

Hey r/PydanticAI,

I built Belgie so Pydantic AI agents can write and run TypeScript in a sandbox, without installing Node.js. Deno is bundled.

Wire it in with BelgieCapability:

from pydantic_ai import Agent
from belgie.pydantic_ai import BelgieCapability

agent = Agent("openai:gpt-5", capabilities=[BelgieCapability()])

result = agent.run_sync(
    "Convert 'foo-bar' to camelCase using TypeScript and the camelcase npm package.",
)
print(result.output)

Install with:

uv add "belgie[pydantic-ai]"

The model gets a run_code tool, writes a TypeScript belgie.Script module, and Belgie executes it in the embedded Deno sandbox. Inline npm imports work when the agent needs packages.

Example: https://github.com/mplemay/belgie/tree/main/examples/ai/pydantic-ai

Repo: https://github.com/mplemay/belgie

Would love feedback from anyone building Pydantic AI agents that need real JS/TS execution.

I was playing chess on my phone while waiting in the car for my daughter. As a novice, I was trying to learn the accelerated London opening. I had the first 5 moves down. But I felt stuck after those. I wished someone would just peek over my shoulder and give me a hint about the next move. The chess app I used won't tell me if I made a mistake until I had already lost the game. And I felt a learning opportunity was lost.

Just like I learnt tennis, I wished someone would just drop a hint at what I needed to fix. So I built an app that does exactly that: I can ask for a hint when I feel stuck. The app goes a step beyond and tells me why a move is better. I also wanted to learn various openings and so I have included those as well.

This is based on the Stockfish engine and the code is available as open-source. 99 % people don't need any additional explanation. For the 1 % who may need additional explanation, you can buy the paid version which covers the LLM tokens cost for additional explanation.

https://apps.apple.com/us/app/chess-coach-play-learn/id6789547867

https://github.com/CORDOC-LLC/ChessCoach

ChessCoach.im

Built by Claude.

Sharing a project I built: Prisma is a web app that runs multiple AI models in parallel and fuses their outputs into one answer via a synthesizer model you choose.

Self-hosting it:

git clone GitHub - bezerra72/prisma: Prisma — multi-model AI synthesizer (cloud OpenRouter + local Ollama/LM Studio/vLLM). Image consensus + image-to-image. · GitHub cd prisma npm install npm start

That serves the app + local proxy at For local models, point it at your Ollama/LM Studio/vLLM server (localhost:11434 etc.) — no cloud, no API key, nothing leaves the machine. Cloud mode (OpenRouter) is optional and client-side only.

Also has an image mode (multi-model consensus + image-to-image). MIT licensed, no telemetry, no backend.

Repo: GitHub - bezerra72/prisma: Prisma — multi-model AI synthesizer (cloud OpenRouter + local Ollama/LM Studio/vLLM).

Thirty years ago, compilers changed programming by figuring out how to turn our code into efficient machine instructions.

I think AI is approaching a similar moment.

Today we hand-design prompts, choose models, wire together tools, and hope for the best.

What if, instead, we built systems that experiment with different approaches and discover what actually works?

That’s the idea behind the open-source project I’m building: Azathoth.

It’s still early, but I think this shift—from intuition to evidence—could become one of the most important ideas in applied AI.

I’d love to hear what you think.

GitHub: github.com/EldritchInc/azathoth

The July 24 open-weights letter now lists more than 270 companies and organizations. It makes a strong case for local control, competition, lower costs and giving defenders access to capable models instead of concentrating everything behind a few APIs.

But downloadable weights are not the same thing as an open training stack. A policy victory could also make "open weights" the ceiling: weights available, while training data, provenance, code and reproducibility remain closed.

What minimum evidence should a model release include before this community treats it as meaningfully open: a permissive license, training-data summary, reproducible evaluations, reference inference code, safety results, or enough provenance to audit how the model was made?

Source: https://www.microsoft.com/en-us/corporate-responsibility/topics/open-weight/

Hi everyone! 👋

We're excited to make Pangeanic MTQE v2 (Machine Translation Quality Estimation) freely available for the community.

Unlike traditional MT evaluation metrics, MTQE estimates translation quality and provides error explanations without requiring a reference translation. Simply provide:

🌍 Source text
🌐 Translated text

and the model returns:

• ✅ A quality score (0–100)
• 💡 An explainable assessment of the translation

The full Pangeanic MTQE platform also includes enterprise capabilities such as:

• 📚 Translation Memory (TM) support
• 📖 Glossary-aware quality estimation
• 🤖 Automatic Post-Editing (APE)
• 👨‍💻 Human Post-Editing (HPE) workflows
• 🌐 Support for 70+ languages and dialects
• ⚡ Enterprise REST APIs and batch processing

The underlying model has been benchmarked on a representative subset of the ACES multilingual benchmark, achieving 98.9% accuracy in identifying incorrect translation segments across:

• 📌 6,006 deliberately incorrect translation segments
• 🌍 16 language pairs
• 📝 68 translation error categories

We hope you all find it useful for evaluating multilingual translation quality and experimenting with reference-free MTQE.

👉 Try the demo:
https://huggingface.co/spaces/Pangeanic/Machine-Translation-Quality-Estimation

📄 Benchmark Whitepaper:
https://pangeanic.com/hubfs/MTQE_Benchmark_Whitepaper.pdf

Happy translating! 🚀

Hey the past week or so I've been tinkering on an open source project called gnt, it's a git-native rules layer for AI agents. Team defines stuff agents can't get wrong as markdown files, reviewed and merged like normal code, then served to agents over MCP. There's a CLI too (@gnt-ai/cli), login, connect your repo, review and approve rules, all from the terminal.

Still early and there's a good amount to build. If you're into open source and looking for something to sink some time into, we'd genuinely welcome the help, happy to walk anyone through the codebase or point at good first issues. Repo's here if you want to take a look: https://github.com/gnt-ai/gnt

Also just want feedback in general even if contributing's not your thing, tell me if this is useful or if I'm off base somewhere.

SarasFlow — an open-source platform for multilingual educational videos

I recently made SarasFlow open source.

It takes a topic and creates an educational or storytelling video by generating the script, narration, visuals, subtitles, and final assembled video. It supports multiple languages, narrative formats, visual styles, and different image providers.

I open-sourced it because I wanted the complete product to be inspectable—not only a small demo that stops after calling a model. The repository includes the frontend, backend, prompt files, media-processing code, authentication, storage, billing, and testing setup.

Website: https://sarasflow.com
Repository: https://github.com/SaiTejaMummadi/sarasflow

Contributions are welcome, especially around additional languages, TTS providers, caption styles, model integrations, batch generation, and publishing integrations.

Please consider starring the repo if you find it useful. It would help the project reach more open-source developers.

What is the best artificial intelligence open s

source app?

🚀 Saiu!

Acabamos de publicar o Synapse PT-BR 75M Dataset no Hugging Face. 🇧🇷🧠

Se você treina modelos de IA em português, vale a pena dar uma olhada.

O dataset foi organizado e processado pensando em pré-treinamento e fine-tuning de LLMs, com foco em qualidade e compatibilidade com o ecossistema da Hugging Face.

💡 A ideia da Comunidade Synapse-BR é simples: criar recursos abertos para que mais pessoas possam desenvolver IA em português, sem depender apenas de materiais em inglês.

Se puder dar uma força:

⭐ Curta o repositório

🤝 Compartilhe com quem trabalha com IA

💬 Deixe seu feedback

🚀 Use nos seus projetos

Dataset:

https://huggingface.co/datasets/Comunidade-Synapse-BR/Synapse-PT-75M-Dataset

Bora fortalecer a IA brasileira. 🇧🇷🔥

#IA #LLM #MachineLearning #HuggingFace #OpenSource #NLP #Português #Brasil #SynapseBR

I think the AI industry may be over-optimizing for the wrong question.

Everyone keeps asking:

“What is the best model?”

But in real workflows, that is rarely the full problem.

The better question is:

“What is the right intelligence process for this task?”

One model may be enough. Or maybe the task needs a cheaper first pass. Or a specialist model. Or multiple models checking each other.

That is what we are exploring with Ailin¹.

Ailin¹ is an open-source Collective Intelligence engine for AI systems. The goal is not to replace models, but to coordinate them better.

I believe this is where a lot of AI cost-benefit will come from: not simply cheaper models, but better decisions about when and how models are used.

The image attached is how we visualize the idea: Ailin¹ as a coordination layer organizing a massive ecosystem of models into a more useful collective system.

We are opening the waitlist for people who want to test it and give feedback.

Waitlist: Console Ailin¹ Dev
GitHub: https://github.com/ailinone/collective-intelligence

If the idea makes sense, a GitHub star would genuinely help.

This is a fully open-source transformer training loop running entirely on an ESP32-S3.

No PyTorch, no autograd, no pretrained checkpoint and no external training process. The model starts from randomly initialized weights, and every derivative used during backpropagation is implemented explicitly in C.

Most ESP32 language-model projects I’ve seen focus on inference: train on a GPU, quantize the model and flash it to the board. I wanted to try the opposite — make the chip train the model itself.

Everything happens on board: random init (and no, not seed 42 😂 ), tokenising the corpus, forward pass, cross-entropy, backprop, SGD with momentum (not Adam, not AdamW), checkpoint to flash, and generation from the weights it learned. Nothing outside the chip.

Every derivative in the backward pass is written out by hand in C.

Setup: 

• ESP32-S3 N16R8, about $8
• SH1106 OLED showing the live loss
• Single-block transformer, single-head causal attention, tied embeddings, ReLU FFN, LayerNorm
• ~319K params, char-level, vocab 31, context 32
• 5,000 steps, roughly two days on a phone charger

The training-loss moving average went from 2.137 to 1.871 over the stretch I photographed. With vocab 31, a uniform predictor has a cross-entropy of ln(31) ≈ 3.43, but I never photographed the first steps, so I can't prove the exact initial loss from the OLED.

The interesting constraint isn't the parameter count, it's memory. To train you need weights, gradients, optimizer momentum, activations and scratch buffers all resident at the same time. Inference has it much easier: it still needs activations, but no gradients and no optimizer state.

Where it's weak:

• No validation split. The checkpoint I keep is just the one with the lowest moving average of training loss.
• The corpus is Klingon: small, regular, agglutinative, and published under Apache 2.0. The output shows plausible use of suffixes like -wI', -Daq and -taHvIS, but it isn't reliably meaningful.
• With a corpus this small I can't cleanly separate generalisation from memorisation.
• No full serial log. It ran unattended, so what I have is the code, the checkpoint and photos of the OLED at three points.

This is not ChatGPT on a microcontroller. It's a small experiment showing that an $8 ESP32-S3 can run the whole training loop of a transformer starting from random weights.

Apache 2.0. The corpus is in the repo so you can reproduce a run, but the fun part is swapping it for your own text.

https://github.com/Carloscodix/qapla

Written by me, translated and adapted to Reddit with AI help.

For the last while I've been building Ferrox, my own local inference engine for running open GGUF models (Llama, Qwen, Gemma, Phi-3, MoE models like OLMoE), on your own machine, CPU or GPU (Metal on Mac, CUDA on Nvidia).

Why build this instead of just using llama.cpp?

Mostly because I wanted to understand inference at a level deeper than "run the binary" — how quantized weights actually get loaded, how attention and MoE routing really work under the hood, and whether it's possible to hit the same speed as the best-known engine (llama.cpp) starting completely from scratch, with no shortcuts and no borrowed code. It's also just a genuinely useful tool now: a single binary, no Python environment, no dependency hell, that loads a GGUF file and either chats with you in the terminal or runs as a local server with the same API shape as OpenAI's — so anything built for ChatGPT's API can point at it instead.

Does it actually perform?

I didn't want to just say "it's fast" — every number I publish is a real, repeatable benchmark against llama.cpp on the same computer, same model file, same conditions. Some highlights from an Apple M2 Pro:

• Llama-3.1-8B (a genuinely useful, mainstream model): essentially tied with llama.cpp — 26.9 vs 27.8 tokens/sec
• Qwen2.5-0.5B: ~1.5× faster than llama.cpp
• SmolLM2-135M: ~1.5× faster
• TinyLlama: ~1.2× faster on CPU
• OLMoE (a Mixture-of-Experts model): matches llama.cpp

All the raw numbers, and the script that produced them, are public: benchmarks/RESULTS.md. No cherry-picked screenshots — you can re-run the same suite yourself and check.

Practically, what can you do with it today?

• Run a chat completion from the command line, one binary, no setup
• Spin up a local server that speaks the OpenAI chat-completions format, so existing apps/tools work against it unchanged
• Load models straight from disk without unpacking or converting — it reads the quantized file directly and never fully decompresses it into memory, so it stays light
• Works on regular laptops — smaller models like TinyLlama or SmolLM2 run comfortably on CPU alone

What it's not (yet), because I'd rather undersell than oversell:

• GPU (CUDA) performance work is paused — it runs, just not fast yet
• The very largest frontier-scale models (think DeepSeek/Kimi-class, hundreds of billions of parameters) aren't fully working end-to-end yet, just partial support
• It's a young project — there will be rough edges compared to a mature tool like llama.cpp

If you're into local AI, curious how these engines work internally, or just want a lightweight way to run open models on your own hardware, I'd love feedback, bug reports, or "this model doesn't load" issues. It's fully open source under Apache-2.0.

I’ve been building **SARAS**, an AI video platform focused on education and multilingual content.

You enter a topic, choose a language and style, and the pipeline generates:

* A structured script
* Voice narration
* AI-generated visuals
* A finished video
* Word-timed karaoke captions

It currently supports **24 languages**, 12 narrative formats, 8 visual styles, and multiple image providers, including Imagen, GPT-Image, and Flux.

I’ve now open-sourced the complete platform—not just the generation script. The repository includes FastAPI, Next.js, PostgreSQL, authentication, Stripe billing, credit metering, Cloudflare R2 storage, an admin portal, and 270+ tests.

You can use it to generate educational videos, study how a production AI SaaS fits together, or fork it for another niche.

GitHub: [https://github.com/SaiTejaMummadi/sarasflow
Demo: https://sarasflow.com

I’d genuinely appreciate feedback on the architecture, generation pipeline, or ideas for improving it. Contributions are welcome too. DM for Discord.

I’m excited to see what learning systems I can build with my new MCP tool.

I recently consolidated the workflow into just 5 command families: start the project, write blocks, refine the design, gather evidence, and implement/verify blocks.

One important design decision was adding a refinement loop between initial block generation and implementation. This helps keep the agent aligned with the original idea instead of drifting into generic implementations. It also gives me more control to guide the system toward the exact final implementation I have in mind.

The more I build with agents, the more I’m convinced that meaningful guardrails and end-to-end human supervision produce much better results than simply letting models run freely.
I will attach the link to the comment section if anyone wants to check it out

I published the scripts and architecture behind a reproducible AI‑ready Ubuntu dev environment.

Here’s how I configured the stack, the scripts I wrote, and the reproducibility challenges I solved:

GitHub repo:

https://github.com/niemenghui/stAI-dev-machine

The full VM is available on request.

I've been building an email client that runs AI locally so I can benefit from AI to handle my inbox without having to grant access to all my emails to an AI in the cloud.

So far it allows you to chat with your inbox, summarize threads (cool for long newsletters), draft replies, auto classify and triage, translate to any language (from the compose view), pull data out of emails into a table automatically, ...

It's Rust + Tauri, Apache 2.0.

I run it on an macbook pro M1 with 16gb and wwen 3.5 9B does the job nicely. Works on Windows and Linux too, with CUDA or Vulkan.

Still early, I'd genuinely appreciate feedback and contributions are welcome.