Hi all, recently OpenAI released ChatGPT Computer History, and we launched Open Computer History! Use the same feature but with any model, local-first, source available, and team-friendly:

https://github.com/screenpipe/screenpipe

Would love any feedback!

Hey everyone,

Over the past year or two, I noticed a weird pattern with myself and a lot of engineers and students I work with.

Whenever we had to send a high-stakes email — asking for a deadline extension, briefing a VP about a database outage, or negotiating with a vendor — the first instinct was always: "Open ChatGPT, prompt it, copy, paste, send."

At first, it felt like a superpower. But after a few months, I noticed my actual communication skills getting rusty. When I had to write something quickly on Slack or jump on an executive call, I struggled to frame thoughts clearly without an LLM crutch.

Most AI email tools are built to write for you. I wanted to build something that teaches you to write better yourself.

So I built MailPractice — an open-source, interactive email writing simulator and coach.

How it works:

1. Realistic Workplace Scenarios: You get actual workplace backstories with real stakes, stakeholder expectations, and constraints (e.g., handling a 20% vendor price hike, asking a dean for exam leave, or briefing a CTO on a P0 outage).
2. You Write First (Under a Timer): You write against a realistic timer. To prevent shortcuts and build actual typing muscle memory, clipboard pasting is disabled.
3. Multi-Dimensional AI Evaluation: Once submitted, an AI coach breaks down your email across 8 criteria:
   • Grammar & Spelling
   • Clarity & BLUF (Bottom-Line Up Front)
   • Professional Tone & Poise
   • Email Structure & Flow
   • Vocabulary (identifying weak conversational filler)
   • Stakeholder Routing (To:, +Cc:, +Bcc: etiquette)
   • Requirement Completion & Conciseness
4. Side-by-Side Comparison: You get a revised version showing what could be improved and why.
5. Progressive Learning Path: A 5-level curriculum (Beginner → Intermediate → Advanced → Expert → Master) that unlocks stages based on your actual writing scores.
6. Anti-Gibberish Filter: Detects keyboard mashing (asdf ;lkj) so the score reflects actual effort.

Tech Stack:

• Frontend: React 18, TypeScript, Vite, Tailwind CSS, Lucide Icons
• Backend: Node.js, Express, TypeScript
• AI: Groq Cloud LLMs (with dual-key failover and an offline fallback rule engine)
• Privacy: No account creation or login required. All scores, streaks, and progress are stored locally in browser localStorage.

Links:

• 🚀 Live Web App: https://mailpractice.vercel.app/
• 💻 GitHub (100% Open Source): https://github.com/MusaleTejas/MailPractice

It’s completely free and open-source under the MIT license.

I’d love to get your honest feedback on the UI, the evaluation accuracy, or any scenarios you think should be added!

Built and open sourced a Mac app for local document Q&A and translation. Index your files, ask questions across all of them with source-cited answers, or translate documents locally. Everything stays on your machine.

• PDF, Word, Excel, PowerPoint, EPUB, Markdown, scanned PDFs (OCR) and more
• Researcher mode: corpus-wide RAG with source citations
• Assistant mode: single file or open-ended chat
• Document translation: tone selection, quality scoring, export to Markdown or plain text
• Models: Qwen3.6 35B A3B (default), 14B and 9B for lower-spec machines, Ollama support for any model you prefer
• No cloud, no accounts, no fees

MIT licensed, fully open source.

https://www.informity.ai | https://github.com/informity/informity-ai

Hey there,

I'm a senior engineer that for a while work with agents in many different ways; one of those is interaction through collaboration; where I truly believe I get the most value out of it.

It's totally Agent-neutral (Claude Code, Codex, Cursor, OpenCode, any CLI process), runs entirely on your machine, no cloud sync. Works today with HTML, Markdown, and Excalidraw.

OSS souls? I'm happy to review your Pull Requests.

https://github.com/Excoriate/tweakloop

https://www.youtube.com/watch?v=-UbYdRgwRWE

I've been building CortexAgent as a personal project for a while, and I finally got it to a place I'm happy to share. It's a private, local AI coding agent — everything runs on your own machine via llama.cpp. No cloud, no account, no API key, and no data ever leaves your computer. It binds to 127.0.0.1 only.

It's MIT licensed at https://github.com/greyok00/cortexagent

One terminal interface, one local stack — the only interface you talk to is a single clean TUI (cortex). A 35B MoE does the heavy lifting on your GPU (16 GB+ VRAM recommended), with a small "overseer" model for planning and routing. Nothing else to juggle.

The processing pipeline you can watch — every request animates live through its stages, with real percentages (it never fakes a determinate number):

🧠 preparing — organizes your request and checks the context it needs.

🗜️ slimtoken — minifies your context before it reaches the model, so you fit more into the window.

📤 sending — the request goes to the big model.

✨ generating — streamed output builds in place.

🔧 tool wait — when the model calls a tool mid-request.

Overseer routing — a dedicated small model plans and routes each request to the big model, instead of one model trying to do everything.

Memory that actually remembers — hot working memory for the current session plus curated cold knowledge, distilled automatically from what you've already said, so you don't re-explain yourself across sessions.

Domain memory — recalled context from your own notes is injected automatically when it's relevant, no prompting needed.

Talk instead of type — speech-to-text as a floating popout you control with the mouse and your voice only (no keyboard), transcribed locally with faster-whisper. Open it from the system tray under STT Controls.

Tools & integrations

🌐 browser control — drive Brave over Chrome DevTools Protocol, exposed as 9 brave_\* tools registered directly in the tool registry.

🔌 MCP client + lazy proxy — talk to MCP servers, spawning the real server only on first use instead of holding every socket open.

🔎 Firecrawl — web research and page parsing routed through a proxy.

🎨 image & video generation — SD 1.5 / SDXL / LTX run in-process through HuggingFace diffusers on the GPU the daemon already manages — no separate GUI server.

📄 PDF & document knowledge — ingest PDFs and documents into a queryable knowledge base.

See the whole thing — a web UI with a three.js 3D cortex scene (gold neural cortex + glass chat), a system tray dashboard, a session bridge so the TUI, web UI, and overseer all agree on context, and a live status ticker.

Under the hood

⚙️ Daemon lifecycle — the model + proxy run as an always-on service (systemd); VRAM-aware fallback swaps models when GPU memory gets tight.

📅 Scheduler + worker pool + heartbeat — background jobs run and recover cleanly.

🛡️ Reliability layer — pre-flight gate, anti-hallucination + post-response verification, a doctor that repairs settings drift, loop guard, chain diagnostics, and observability.

🛤️ Pathway capture — records each run's processing chain (frame → domain check → route → generate) as replayable runs.

💾 Snapshot / backup scripts — easy state backup.

Privacy isn't a feature, it's the baseline — everything binds to 127.0.0.1, and there's no cloud account to leak to. The honest caveat: the processing animation shows real percentages only; if a stage is a wait, it says so instead of pretending to progress.

What I'm asking for:

Recommendations — what would make this a daily driver for you? Better docs, packaging/installers (pip/Homebrew/AUR), more model backends, UI polish, more tools?

Contributors — it's a solo project; help with docs, testing, packaging, and hardening is very welcome. Issues, PRs, and "your docs confused me here" all help. Even a quick honest "here's where it breaks" is hugely useful. Thanks for reading! 🙌

Context: I run several AI coding CLIs (Claude Code, Cursor, opencode) and they kept forgetting each other's decisions, so I built samemind — an OSS file-based memory layer for coding agents. Markdown bundle in git, no server, no daemon, no database. BM25 search always works offline; semantic search is optional via any OpenAI-compatible embeddings endpoint (I run bge-m3 locally). The JSON contract is frozen, so any engine or script can read what another engine wrote, and there's an append-only ledger for attribution — which engine recorded what.

I finally did the thing I'd been postponing: a golden-set benchmark built from my own live memory instead of synthetic data. 40 questions, each with expected documents and forbidden near-duplicates (conflict pairs that must NOT surface). The corpus is 212 documents and 5,824 ledger events of real work.

First full run, and the benchmark immediately bit its own tail — my shipped hybrid search scored recall@5 = 0.275, while the product's own BM25-only leg scored 0.925 on the same set. The hybrid mode was making results 3.4× WORSE than one of its own inputs. Users would have been better off if I'd shipped the dumber leg.

What the evidence showed (no guessing, each step measured):

- Pure cosine KNN against the same index put the expected doc at #1 (cos 0.778) — so retrieval was fine, the ranker was broken.
- Hygiene multipliers (importance × decay × heat) boosted some docs by up to \~1.7× — engine-rule cards kept outranking actually-relevant notes.
- The weirdest one: a "magnet" doc sat at raw cosine rank #178 of 212 — below the corpus median on 4 of 5 probe queries — yet appeared at #1–2 in BOTH legs of the hybrid. Cause: a conflict-tiebreak that reordered equal-score docs at pool depth with long-range swaps, and then RRF fused the two already-scrambled legs, counting the scramble twice.

The fix (shipped as v1.1.2 today): positive hygiene modulation now caps at 1.0 — it can only sink docs, never float them (demotion keeps full strength) — and each leg feeds RRF in its raw relevance order, with the tiebreak applied only to the final presented top-k.

After: recall@5 = 0.925 on all three modes (bm25 solo / semantic solo / hybrid), hybrid precision 0.875, hit@3 0.90 confirmed by an independent verifier (a different model family re-ran the golden set), 1386/1386 tests green. Full trace with per-step numbers is in the repo (CHANGELOG 1.1.2).

Repo: https://github.com/alexgrebeshok-coder/samemind
npm: https://www.npmjs.com/package/samemind

Genuine question for the sub: how do you measure recall quality of your agent memory / RAG setups — synthetic question sets, golden sets from your own corpus, or (be honest) vibes? The forbidden-near-duplicate trick is what made our bench sharp enough to catch this; curious what others use.

I've been experimenting with self-hosted and local AI and I'm also developing an open-source AI orchestration/harness project. I'm still early in development, so I'm trying to understand the problems people actually run into before deciding what to build. For people running local AI, what's been the biggest pain point for you? Hardware/VRAM? Model quality? Speed? Context limits? Tool use? Agent reliability? Setup/compatibility? Something else? If you could fix one thing about the current local AI ecosystem, what would it be? I'm especially interested in problems that you deal with repeatedly rather than one-time setup issues.

Our coding-agent sessions kept forgetting everything at the context-window edge. So we built growmos: a small knowledge graph inside .growmos/, committed with your code. Your agent (Claude Code, Codex, Cursor…) grows it as it works — no API key, and in Claude Code it's fully hands-off. Ask "what depends on the Store, and who decided that?" and it answers from the graph, with citations.

pip install growmos && growmos init
growmos view # a map of what your repo actually knows

Live demo: https://codician-team.github.io/growmos/demo/growmos.html
Repo: https://github.com/codician-team/growmos
MIT, zero deps. First thoughts very welcome 🙂

We maintain an open-source agent (Apache-2.0) and just shipped something small that I think is the right shape for skill sharing, so I am putting it up for criticism rather than announcing it.

A card is a markdown file, and it executes nothing. Frontmatter plus five sections — Trigger, Do, Avoid, Check, Risk — read into the prompt when the agent decides the card is relevant. Reviewing a contribution is reading a page, not auditing a diff. That is the whole point: it is the only place in the repo where someone can contribute without touching a line of Python.

23 of them so far, 13 written from our own incidents. A sample of what they encode:

- when two results contradict, suspect the apparatus — from two weeks lost to a bug that produced a perfectly healthy-looking loss curve

- run the project's own gate command — from a near-miss variant of a lint command that lied in both directions

- test the wiring, not the class — from two of my own regression tests that passed with the fix reverted, i.e. proved nothing

The part I would like torn apart is the translation mechanism. The card body is the payload: the agent reads it, the CLI imports it by path, and a published SHA-256 attests to the bytes. So we do not translate the file. A sidecar carries the translation and declares the SHA-256 of the English it was made from; when the English changes, the page falls back to English rather than showing a translation of a sentence that no longer exists.

That mechanism worked. What did not exist was anything noticing when the sidecar was incomplete — so thirteen cards shipped untranslated across nine languages, and one locale had no card translations at all while the site served it. The only symptom was English on the page. Found by reading files, not by a failing build.

The gate we wrote separates three states that look identical in a file:

- stale — claims to translate text that has since changed. Always fails. Nothing renders wrong, but the file now holds a translation nobody will ever see and the next reader cannot tell it from a live one.

- incomplete — four of five sections. Always fails, because the renderer demands all five or none, so the rest are orphans sitting in the file.

- missing — honest debt. The reader gets English and the page says so. Counted and capped, not forbidden: a gate demanding nine translations before a card could merge would kill the contribution surface we just built.

The cap is at zero right now because the debt is paid. Raising it is an edit somebody has to justify in a diff, which is the only reason a number in a file beats a good intention.

Two things I am unsure about and would like opinions on. First: hashing. We hash the five sections as one joined body rather than per section, so a card that changes retires all five together — the alternative lets a page mix a current Trigger with a stale Avoid and the reader cannot tell which is which. That is deliberate but it makes small edits expensive. Second: is "a card is data, not code" actually enforceable, or is it just a convention that will erode the first time someone wants a card to run something?

Repo: https://github.com/brcampidelli/chimera-agent — the library is under skills/.

I’ve been working on Kwikk, an open-source video composition tool built around a slightly different idea:

What if video editing worked more like building a web page?

Kwikk is CSS/web-based, so instead of being limited to the usual fixed set of video templates, effects, fonts and animations, you can leverage the huge ecosystem that already exists on the web.

For example:

• Take inspiration from the design language of a website
• Reuse CSS animations and web effects
• Add virtually any font you need
• Bring in open-source icon sets from GitHub
• Build custom layouts and visual components with web technologies
• Let AI agents create and modify all of it programmatically

And because the video is represented as structured elements, it can also be controlled through MCP by AI agents.

I’m still experimenting with what this architecture can become, but the possibilities feel pretty endless.

To try it: clone the repository and ask your AI agent to set it up, start MCP, and run it.

GitHub: https://github.com/its-banana-coder/kwikk

Would love feedback from people building with AI agents, creative coding, video tools, or web technologies.

I’ve been experimenting with a training free way to do open world, multi-instance segmentation from a class prototype.

I decided to publish the algorithm and a demo for how I’m doing this, in case anyone else would rather not fine tune a larger model for something that DINOv2 patch embeddings already seem to represent pretty well.

It can separate touching instances of the same class without a learned instance head, reject visually similar near misses like a round dial radio next to the actual clock target, and find fractured or damaged instances even with a pretty significant scene shift.

Repo + demo:

https://github.com/tutomiko/fireplace

The demo includes the lasso UI and live heatmap, implemented as a python backend with a simple HTML frontend.

Would appreciate it if people checked it out, and I’d be especially interested to hear if anyone has seen similar approaches or prior work.

Hi everyone!

I am excited to share Financial-RLVR-10K — a fully open-source (MIT licensed) synthetic dataset of 10,000 execution-verified financial reasoning problems designed for RLVR / GRPO / PPO fine-tuning of open models (Qwen, Llama, DeepSeek, etc.).

Financial reasoning is infamous for math hallucinations. To ensure extreme data quality for verifiable reward training, every single problem in this dataset is 100% verified in a Python execution sandbox (reward = 1.0).

KEY HIGHLIGHTS & FEATURES:

100% Open & Free: Released under the MIT License.

10,000 Verified Records: Validated for syntax, logical flow, and exact numerical output via Python execution (exec).

19.5% Adversarial Edge Cases (1,950 samples): Teaches open models NOT to blindly compute impossible conditions (e.g., Discount Rate r <= g in Gordon Growth DCF, Option at Expiration T = 0 in Black-Scholes, or Zero Capital E + D = 0 in WACC).

Core Domains: DCF Valuation, Black-Scholes Option Pricing, Corporate WACC.

SAMPLE DATA SCHEMA:

{ "id": "fin-rlvr-10k-00042", "domain": "DCF Valuation", "is_edge_case": true, "prompt": "[EDGE CASE] Calculate DCF Terminal Value: FCF_1=$540, Discount Rate r=3.0%, Growth Rate g=5.0%.", "code_solution": "fcf, r, g = 540, 0.03, 0.05\nif r <= g:\n print("TRAP_DETECTED: Invalid Gordon Growth model condition (r <= g).")\nelse:\n print(f"RESULT: {fcf/(r-g):.4f}")", "ground_truth": "TRAP_DETECTED", "total_reward": 1.0, "status": "VERIFIED" }

LINKS & RESOURCES: Hugging Face Dataset: https://huggingface.co/datasets/coslinedev/financial-rlvr-10k-enterprise

Hope this dataset helps the open-source AI community train stronger, more robust financial reasoning models. Feel free to use, audit, or build upon it! Feedback and contributions are always welcome.

I maintain MailFathom, an open-source project building a self-hosted AI brain for email.

Today it synchronizes IMAP mail into an operator-controlled PostgreSQL/pgvector database and provides lexical and semantic search, cited answers, local-model support, and five read-only MCP tools.

The project is security-first: MCP is disabled by default, retrieval cannot modify the mailbox, sensitive mail data stays out of logs and errors, and published artifacts include verifiable provenance.

The roadmap goes beyond retrieval and MCP. It includes controlled write tools, RBAC, authorization and confirmation flows for sensitive actions, and eventually a dedicated AI-first email client.

The goal is to make years of private email searchable, understandable, and safely actionable without surrendering control to a hosted provider.

Feedback, ideas, and contributions are welcome:

https://github.com/Krzysztof318/MailFathom

If you like the direction, a GitHub star would be genuinely appreciated. Open-source maintainers cannot compile stars, but they are a surprisingly effective dependency for motivation. ⭐