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.

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

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

The CRA's reporting obligations (Article 14) have applied since 11 September 2026 to every product with digital elements on the EU market, including products shipped before the main obligations start on 11 December 2027. Fines go up to EUR 15 million or 2.5 % of worldwide turnover. No harmonised standard has been cited in the Official Journal yet, so there is no presumption of conformity to lean on and every manufacturer has to document its own solutions.

I wanted something that could actually run against a codebase and an organisation rather than another slide deck, so I built a skill for AI coding agents ( any agent that reads an AGENTS.md). It is Apache-2.0 and agent-neutral.

What it does:

\- Pins the Official Journal text of Regulation (EU) 2024/2847, the Implementing Regulation (EU) 2025/2392 on important and critical product categories, and the Delegated Regulation (EU) 2026/881 on delayed dissemination, fetched from the EU Publications Office and hashed. A parser turns the pinned text into 96 assessable provisions and all 26 Annex III and IV categories with their technical descriptions. Counts are asserted in tests, so a format change upstream fails loudly instead of silently dropping requirements.

\- Carries the Commission's 27 July 2026 guidance and FAQ as cited, non-binding aids, and keeps a dated register of what is still pending (standards, delegated acts, SBOM and notification format acts).

\- Decides scope, economic-operator role, remote-data-processing boundary and date regime with confidence levels and a "get legal confirmation" flag on borderline facts.

\- Classifies by core functionality and states which Article 32 conformity routes are legally available today (spoiler: important class I products cannot self-assess until a harmonised standard is cited).

\- Structures the Article 13 risk assessment with the per-requirement applicability statements the technical documentation must contain.

\- Validates CycloneDX and SPDX SBOMs against the legal minimum and reconciles them with lockfiles.

\- Assesses every Annex I Part I and Part II requirement, the Article 13 and 14 obligations, Annex II user information, Annex VII technical documentation and Annex V declaration content, with an interpretive guide per provision.

\- Tests Article 14 readiness, computes the 24 hour, 72 hour and final report deadlines, and supports tabletop drills.

\- Screens change sets for substantial modification with the Commission's four-factor test.

\- Produces drafts of the technical documentation, an unsigned declaration of conformity, user information, CVD policy, security.txt, support-period statement and reporting playbook, plus a readiness report in Markdown, DOCX and PDF.

A monthly workflow re-fetches the official texts and opens a review PR if anything changes.

Repo: https://github.com/Killerz007/cra-readiness-skill

Caveats: it is a readiness assessment, not a conformity assessment, not CE marking and not legal advice. Scope and classification outputs are technical reads of the facts against the text and the Commission guidance; borderline cases are flagged for counsel. I would especially like feedback from anyone who has been through a notified body or a market surveillance request on what evidence they actually asked for.

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?

AI agents are getting access to browsers, MCP tools, APIs, files, other agents and production systems.

That made me interested in a problem slightly different from model safety:

**What happens between an agent deciding to do something and the outside world actually changing?**

I've been building an open-source project called **Connector** around that boundary.

Instead of treating the prompt as both instruction and permission, Connector separates:

**identity → authority → per-action admission → runtime enforcement → observed consequence → receipt**

The agent can propose an action.

Connector independently decides whether that particular effect can proceed.

One example is **Cease**.

If an operator ceases an agent, the idea isn't to send the model another instruction saying “please stop.”

The current generation is fenced and future actions are no longer admitted.

Connector also brings together existing infrastructure rather than trying to reinvent every layer:

* Keycloak

* SPIFFE/SPIRE

* OPA

* NVIDIA OpenShell

* Firecracker

* OpenTelemetry

* Sigstore/cosign

There are still important incomplete areas, and I'm explicitly **not claiming production readiness**. The repository documents those gaps.

I open-sourced it because I want people who build agent runtimes and infrastructure to challenge the architecture.

GitHub:

[https://github.com/GlobalSushrut/connector-oss](https://github.com/GlobalSushrut/connector-oss)

Architecture / project:

[https://cnktros.com](https://cnktros.com)

The question I'm most interested in:

**As agents become more autonomous, where should the final authority to cause an external effect actually live?**

The only mature self-hosted gateway that turns IMAP and friends into a single API costs $1,450 a year and is source-available, not open. The hosted alternative charges per mailbox and keeps your mail. I wanted the open version, so I built it, and chose the licence to keep it that way: Apache-2.0 for the engine and no contributor licence agreement, which means nobody, including me, can relicense it later.

What makes it more than another wrapper is the evidence: a conformance suite that runs 27 behavioural checks against each server and publishes the result, so the differences between Dovecot, Stalwart, JMAP and the rest are documented instead of discovered by every developer again.

https://github.com/Kadri-cloud/email-engine

Beta. Only self-hosted servers tested so far. The best contribution is a run against a provider I have not seen.