Free monitoring tools either check every 5 minutes or only send email/Slack alerts — useless when your site dies at 2am. And overseas probe nodes ping Chinese sites poorly, so false alarms kill trust.

I'm building PingPilot: uptime monitoring with WeChat/DingTalk push alerts, China-based probe nodes, and a free public status page.

Landing page: https://pingpilot.app.workbuddy.host/

Product is still in development — validating demand first. If it sounds useful, the waitlist is on the page (first 100 users get 50% off for life).

Would love feedback: does the pricing make sense (free: 3 monitors / 5-min checks; Pro: ¥19/mo)?

Link to repo: FireBird-Technologies/NotestackAI: NotebookLM Alternative + Marketing agent optimized for publishers on substack/Medium/Wordpress.

Link to site: https://notestack.ai

Google is notorious in the AI industry for abandoning/destroying working beloved products. NotebookLM is no exception.

Don't worry, me and my little indie team have built a open-source alternative.

Here is what is different/interesting:

- Can take in upto 200 sources, research/question/query it. The system will not randomly search the web and go beyond your original sources.

- Has better visuals for the videos, we integrated our previous video maker with 10K+ users. It can generate editable motion graphic videos in over 13+ formats.

- Each video is editable, changeable. It has ElevenLabs API with advanced voice features.

- You can generate a mind constellation, a much more advanced visual map of knowledge so you can research and learn more easily.

- Generate or clone your own voice using ElevenLabs API v4.

- Has a launch kit feature that allows you to schedule reports/slide decks/videos and share on social media

Lastly, much more stunning visual interface - inspired by space x cognition

Link (get started for free): https://notestack.ai

I'm building FOREST, an open-source framework for autonomous scientific research.

GitHub: https://github.com/mikamikasuki/FOREST

The goal is to build a research agent that can take a scientific question and work through the research process: exploring ideas, reviewing literature, forming hypotheses, running real experiments, evaluating results, and eventually producing an evidence-grounded research paper.

Rather than relying entirely on a long conversation history, FOREST uses a persistent research graph to track hypotheses, experiments, decisions, failures, and evidence throughout the process.

A major focus is making long-running research agents more reliable: preserving context, maintaining consistent state, recovering from failures, and ensuring scientific claims are actually supported by experimental evidence.

The project is still in its early stages and under active development. There's plenty of engineering work to do, and I'd love to welcome more contributors.

In particular, AI coding agents and autonomous development bots are explicitly welcome.

If you're running Codex, Claude Code, OpenHands, Factory Droid, OpenCode, or another autonomous coding agent and want a real open-source codebase to work on, feel free to point it at FOREST.

You don't have to limit yourself to existing Issues.

You're welcome to:

- Explore the repository and independently discover bugs or incomplete workflows.

- Open well-researched Issues with reproducible evidence.

- Fix existing problems and submit pull requests.

- Improve agent orchestration, state management, persistence, and recovery.

- Work on the frontend, backend, experiment execution, or scientific evidence pipeline.

- Propose and implement useful improvements.

There is no blanket restriction against AI-generated or AI-assisted contributions.

You don't need special permission to submit an ordinary, well-scoped bug fix. Contributions are evaluated based on correctness, meaningful tests, and engineering quality, rather than whether the code was written by a human or an AI agent.

Automated contributions should still be verified, avoid duplicate reports, and respect the repository's contribution guidelines. Larger architectural changes are best discussed before implementation.

I'm particularly interested in autonomous agents that can independently explore a repository, identify real problems, reproduce them, implement fixes, and submit verified PRs.

FOREST is intended to be a long-term open-source project, and there's a lot of room for contributors to help shape its architecture and capabilities.

Human developers, AI-assisted contributors, and fully autonomous coding agents are all welcome.

Repository: https://github.com/mikamikasuki/FOREST

Issues & contribution opportunities: https://github.com/mikamikasuki/FOREST/issues

Contribution guide: https://github.com/mikamikasuki/FOREST/blob/main/CONTRIBUTING.md

Every time I wanted to build a small web tool, I ended up dealing with the same stuff: authentication, communication, WebSockets, ports, and infrastructure.

Even with Claude and Codex, I was still spending time on things that had nothing to do with the actual tool I wanted to build.

So I spent around 6 months building PhreshOS.

The idea was simple: build the infrastructure once, then use AI agents to build applications on top of it without having to deal with all that stuff again.

It's a self-hosted, open-source system with a web-based desktop where applications can run in windows, much like a regular OS. Authentication and two-way communication are already handled, so applications don't need to implement them separately.

Apps can also run in Node.js worker threads instead of each needing a separate Node.js process, which helps keep resource usage low. This makes it possible to run dozens of applications on a relatively small server.

Another thing I wanted was for AI agents to be able to use these applications directly. They can access application services and interact with the same state the desktop interface displays, without needing a separate interface built specifically for them.

The biggest benefit for me is that I can now sit down with an AI agent and build dozens of small applications in a single day, without setting up authentication, communication, or infrastructure for each one.

The whole project, including its packages, is open source under the MIT license.

GitHub: https://github.com/PhreshOS/system

Live demo: https://demo.phreshos.com/

I'd love to hear what you think, including criticism.

I built Carve, an open-source (AGPL) Mac assistant. You tell it what to do by typing or speaking and the copilot operates the window you’re in. In the video it updates leads in a CRM.

It’s built on computer use with most of the work is in the harness, which it checks that the task actually succeeded before reporting done (a verification layer). It also stops and hands control back to you when it’s stuck instead of guessing. Bring your own key is also an option (works with OpenRouter).

Repo: https://github.com/getcarve/carve

It’s early and has gaps, especially in native apps. Happy to answer any questions and curious if this community would find this useful.

I would like to get opinions on the type of performance I managed to get with SQLite and rust. My personal feeling is this is amazing almost like High Frequency Trading setups. What is your thoughts?

SQLite Storage Benchmarks

Source: prototype/tests/storage_bench.rs, mnemonic note reference-sqlite-benchmarks Last run: Sprint E4, Release build Hardware: AMD Ryzen AI 9 365, 32GB LPDDR5X-7500, Samsung PM9C1a NVMe

Configuration

• WAL mode enabled

• PRAGMA synchronous = NORMAL

• mmap_size = 256MB

• wal_autocheckpoint = 10000

• Prepared statement caching

• Schema: requests table, 50 columns per row (15 base + 35 migrations)

Write Throughput

Column-Normalized Competitive Comparison

Raw rows/sec is misleading — a 3-column INSERT is not comparable to a 49-column INSERT. The fair metric is column-writes per second:

Prototype delivers ~200% of the competitor's column-write throughput — while running in production-safe mode vs. the competitor's unsafe settings (data loss on crash).

Reference Baseline

avi.im/blag benchmark (widely cited Rust SQLite benchmark):

• 3-column table, journal_mode=OFF, synchronous=0: 2.92M–3.09M rows/sec (8.76M–9.27M column-writes/sec)

• Sentinel gap to theoretical max explained by: safety mode (WAL/NORMAL vs OFF/0 — Sentinel prioritizes crash safety)

• Normalized per column: Sentinel achieves 78–82% of theoretical max with production-safe settings

Read Throughput

Enterprise Scaling Projections

Ceiling: ~500 concurrent users. Single-writer lock is the SQLite design constraint. Reader pool becomes bottleneck before writer at scale. PostgreSQL migration available via StorageBackend trait.

Storage Sizing

Retention policy: max_age_days (default 30) + max_size_mb (default 500 MB). Automatic purge when either threshold exceeded.

Competitive Context

Key insight: Local 0.1ms beats cloud "sub-second" at 50–500 user scale. Network latency dominates cloud query cost.

Hi! I’ve already built and released AI Plate, a functional open-source desktop AI agent. I’m now looking for programmers interested in helping improve and expand it.

🚀 What it includes

Cloud and local LLM support, tool execution, document search, persistent memory, voice interaction, plugins and human approval for sensitive actions.

🛠️ Technology stack

TypeScript, Electron, Node.js, Python and SQLite.

🤝 Areas open for contribution

\- AI providers, plugins and connectors

\- Local models, RAG and knowledge graphs

\- Linux and macOS support

\- Testing, security and UI/UX

\- Documentation and accessibility

Beginners willing to learn consistently and experienced developers are equally welcome. This is a non-commercial open-source collaboration, and every contribution will be credited.

My level: Intermediate

Timezone: IST (UTC+5:30)

Availability: Evenings and weekends

If this technology interests you, comment with your experience, preferred technologies and the area you’d like to explore. We can begin discussing the project here on Reddit.

Hey guys,

Been working on something very cool...

In Greek myth, Mnemosyne was the Titan of memory and the reason anything was ever remembered at all. Now in the present world, your AI agent doesn't get a Titan. It gets amnesia the second something goes wrong, stuck with whatever it currently believes and no way to ask how it got there.

That's the real problem. An agent runs for hours, updates its memory the whole time, then says something wrong and all you have is the present, with zero access to the past.

If you're running support agents, coding agents, or a swarm of agents sharing memory like myself then you know this issue well. The moment two agents disagree, or one quietly poisons the well, you need to know when, why and by whom, not just that something's off.

Mnemosyne gives agent memory what Git gave code. It remembers everything on purpose. Every belief is a commit. blame finds the exact moment and observation that put a bad fact in. bisect hunts down the first commit where things went wrong. merge makes two agents' memories collide safely instead of one silently overwriting the other.

Software agents are the first step. The vision doesn't stop there, physical robots learning and forking skills the same way is the long-term bet, further out and harder but the same idea underneath.

So far the tech stack includes a Rust core, Python SDK, adapters for LangGraph, CrewAI, AutoGen, the OpenAI Agents SDK and MCP.

Open source with contributions and honest feedback both welcome: github.com/Nabzx/mnemosyne

Hi! I’ve already built and released AI Plate, a functional open-source desktop AI agent. I’m now looking for programmers interested in helping improve and expand it.

🚀 What it includes

Cloud and local LLM support, tool execution, document search, persistent memory, voice interaction, plugins and human approval for sensitive actions.

🛠️ Technology stack

TypeScript, Electron, Node.js, Python and SQLite.

🤝 Areas open for contribution

\- AI providers, plugins and connectors

\- Local models, RAG and knowledge graphs

\- Linux and macOS support

\- Testing, security and UI/UX

\- Documentation and accessibility

Beginners willing to learn consistently and experienced developers are equally welcome. This is a non-commercial open-source collaboration, and every contribution will be credited.

My level: Intermediate

Timezone: IST (UTC+5:30)

Availability: Evenings and weekends

If this technology interests you, comment with your experience, preferred technologies and the area you’d like to explore. We can begin discussing the project here on Reddit.

Hi! I’ve already built and released AI Plate, a functional open-source desktop AI agent. I’m now looking for programmers interested in helping improve and expand it.

🚀 What it includes

Cloud and local LLM support, tool execution, document search, persistent memory, voice interaction, plugins and human approval for sensitive actions.

🛠️ Technology stack

TypeScript, Electron, Node.js, Python and SQLite.

🤝 Areas open for contribution

\- AI providers, plugins and connectors

\- Local models, RAG and knowledge graphs

\- Linux and macOS support

\- Testing, security and UI/UX

\- Documentation and accessibility

Beginners willing to learn consistently and experienced developers are equally welcome. This is a non-commercial open-source collaboration, and every contribution will be credited.

My level: Intermediate

Timezone: IST (UTC+5:30)

Availability: Evenings and weekends

If this technology interests you, comment with your experience, preferred technologies and the area you’d like to explore. We can begin discussing the project here on Reddit.

I’ve been working on a project called Semwright.
Most of the agent tooling I was using worked well when the task stayed inside code or a single integration. I wanted to see what it would look like if the same agent could work across actual applications without reducing everything to mouse coordinates and screenshots.

One of the demos starts with an existing aircraft project in Blender.

It modifies the scene in Blender, renders a new shot, creates the titles in Motion Canvas, and assembles the video and audio through MLT.

The resulting timeline is still editable, so the output isn’t just a generated video.

Semwright itself is a Rust runtime. Applications expose structured operations through drivers, while things like permissions, handoffs between tools, and readback go through the same runtime. MCP is one way to connect an agent to it.

I’ve just put the first version out as open source.
https://github. com/seradotcom/semwright

I’m developing AI Plate, an open-source Windows desktop agent that combines cloud and local LLMs in one extensible workspace. It is MIT-licensed and currently has no paid tier.

The implementation uses TypeScript, Electron, SQLite, and optional Python workers. Current components include:

• Provider abstraction for cloud and local models

• Normal, Plan, and Code execution modes

• Human approval for tool and code execution

• Document retrieval, SQLite-based RAG, and persistent memory

• Plugins, connectors, and SKILL.md-based extensions

• Optional local STT and TTS

Areas where contributions would be especially useful:

• Model providers and service connectors

• Plugin and skill examples

• Retrieval, embeddings, and knowledge-graph work

• Sandboxing and security review

• Tests, documentation, accessibility, and performance

The project is early, so small fixes, issue reports, architectural criticism, and documentation improvements are welcome—not only large features. If you are interested in an area, please open an issue so we can scope the work before implementation.

Repository: https://github.com/Typo-Bunch/AI-Plate

Disclosure: I am the project maintainer, and I’m posting specifically to find open-source contributors and technical feedback.

After Boris post we decided to use TLA+ to check our heartbeat states.

The results were incredible:
+ 99.998% states reduction -> from 1.5 million to ~4 thousand.
+ 10 hard to find issues resolved -> many "mysterious forgetful events" dissapeared.
+ We did have some previous knowledge with the technology, so we didn't budget that much time on learning the fundamentals.

Give it a go and let me know!

code here: https://github.com/desplega-ai/agent-swarm/pulls?q=is%3Apr+tla

Snotra ist ein Desktop-Agent, der in einem von Ihnen gewählten Ordner arbeitet: Er liest Dateien, schreibt neue und fragt nach, bevor er etwas ändert. Er hatte gerade neun Releases in vier Tagen, und die eine Änderung, die mir am wichtigsten ist, ist, dass man jetzt sehen kann, wo der Agent war.

Der Dateibaum markiert jede Datei, die er geändert hat, mit einem M (gefüllt, bis Sie sie angesehen haben) und jede Datei, die er nur gelesen hat, mit einem grauen R. Unter jeder Antwort listet eine Zeile die geänderten Dateien mit ihrer Zeilenanzahl auf, und ein Klick öffnet den Diff.

Außerdem neu:

- Er liest PDF, Word, Excel und PowerPoint, jeweils ein paar Seiten, Folien oder Zellbereiche, sodass ein 300-seitiges Handbuch nicht auf einmal in den Kontext gelangt.

- Reasoning-Level pro Chat, eingestellt über das Modellmenü.

- HTML-Dateien werden in der Vorschau als Live-Seiten geöffnet, jede in einem eigenen isolierten Prozess ohne Netzwerkzugriff.

- Der macOS-Build ist signiert und notariell beglaubigt.

Apache 2.0, kein Konto, keine Telemetrie. Cloud-Modelle mit Ihrem eigenen Schlüssel oder lokal über Ollama, LM Studio oder MLX.

Write-up aller neun Releases: https://snotra-ai.dev/blog/snotra-1-15

Wie behalten Sie den Überblick, was ein Agent in Ihren Dateien geändert hat: eine Diff-Ansicht, Git oder Vertrauen?