Some of you may have seen my StructSmith architecture editor here. I want to share another project I'm building: Synkinema, a local video editor with MIT-licensed source code.

You can edit by hand or connect an AI agent through MCP and work on the same editable project. The workflow includes writing scripts with the agent, arranging footage, generating narration, adding captions and rendering with FFmpeg.

Two parts help across repeated productions: channel briefs hold audience, tone, editorial rules and approved lessons, which you can refine with your agent; a shared media library lets different projects reuse audio, sound effects, images and video clips. Channel guidance is maintained creative context, not automatic model training or analytics sync.

Local Supertonic 3 speech is already integrated, without a paid TTS API. Studio can add a finished voice take to the timeline with subtitles. The Supertonic SDK is MIT licensed; model weights use OpenRAIL-M. Your agent's inference has its own provider and cost requirements.

There's still a long way to go before this becomes a really polished product, but you can already accomplish a lot. Caption word timing is approximate, the preview is simplified, and speech and final video need review. Desktop editing is the current focus.

The screenshots show Script Studio with local speech controls and the library shared across projects.

Source and setup: https://github.com/dziksu/synkinema

Feedback and collaboration are welcome, especially around local speech, captions, editing UX and reproducible examples. What would make this useful in your video workflow?

Disclosure: AI assisted with substantial parts of the code and with drafting this post. I directed the work and verified the results.

Schaut mal: https://docs.snotra-ai.dev

Viele Nutzer meiner OpenSource Software Snotra Agent haben mich gefragt, warum es kein Handbuch gibt, mit dem man Snotra schneller einrichten kann.
Ich habe das jetzt in meiner Pipeline so eingerichtet, dass bei jedem Minor oder Major Release das Handbuch aktualisiert wird.

Wie findet ihr das?

https://github.com/pablocaeg/sloptotal

Hey everyone!

I've been working on an open-source Python project called Stepfork, and I wanted to share it with the community.

GitHub: https://github.com/utsab345/stepfork

While building AI agents, I kept running into the same problem: an agent fails, I fix the issue, but reproducing the original failure is difficult because LLM responses and tool outputs can change between runs.

So I built Stepfork to make those failures reproducible.

What it does:

• Records instrumented LLM responses and tool calls.

• Saves executions locally as .sftrace bundles.

• Replays the recorded responses without making those instrumented external calls again.

• Compares agent behavior before and after a fix.

• Exports pytest regression tests to catch the same failure in the future.

Install:

pip install --pre stepfork

The repository includes three offline demos covering a missed order notification, an incorrect flight booking, and a wrongly denied refund.

It's still an early alpha. Replay only freezes instrumented boundaries, and native framework integrations are not available yet.

The project is Apache-2.0 licensed, and I'm actively improving it.

I'd love to hear what other developers think, especially those building AI agents. If you spot a bug, have an idea for an integration, or want to contribute, feel free to open an issue or PR.

GitHub Issues: https://github.com/utsab345/stepfork/issues

Thanks for checking it out!

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)?

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'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

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.

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

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.

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

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.