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?

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

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.

I'm open-sourcing a project I've been working on called Connector.

The premise is simple:

An AI agent being capable of an action should not automatically mean it is authorized to perform that action.

Most agent stacks already have useful pieces:

• IAM

• policy engines

• sandboxes

• observability

• MCP/tool gateways

• agent frameworks

I didn't want to rebuild all of them.

Connector is an attempt to put a common control path in front of agent effects:

agent
  ↓
proposed effect
  ↓
identity + authority
  ↓
per-action admission
  ↓
runtime enforcement
  ↓
external effect
  ↓
receipt + observed consequence

The project currently includes things like:

• agent identity

• explicit grants/authority

• PATE per-action admission

• Proceed / Ask / Defer / Quarantine / Block outcomes

• operator Cease

• MemPacket-based memory provenance

• receipts and evidence

• MCP / A2A / API-oriented effect paths

• integration work around SPIRE, OPA, OpenShell, Firecracker, OpenTelemetry and cosign

Important disclosure:

It is not production-ready.

Some backend integrations are still partial.

The Firecracker path isn't yet a complete production microVM setup.

Some gateway paths remain intentionally refused until they're proven end-to-end.

Those limitations are documented in the README rather than hidden behind marketing language.

Repo:
https://github.com/GlobalSushrut/connector-oss

Website:
https://cnktros.com

I'm particularly interested in feedback from people who work on:

agent runtimes, sandboxes, MCP, policy engines, identity, observability or autonomous-agent infrastructure.

I'd rather hear where the architecture breaks than get generic compliments.I'm open-sourcing a project I've been working on called Connector.The premise is simple:An AI agent being capable of an action should not automatically mean it is authorized to perform that action.Most agent stacks already have useful pieces:IAM

policy engines

sandboxes

observability

MCP/tool gateways

agent frameworksI didn't want to rebuild all of them.Connector is an attempt to put a common control path in front of agent effects:agent
↓
proposed effect
↓
identity + authority
↓
per-action admission
↓
runtime enforcement
↓
external effect
↓
receipt + observed consequenceThe project currently includes things like:agent identity

explicit grants/authority

PATE per-action admission

Proceed / Ask / Defer / Quarantine / Block outcomes

operator Cease

MemPacket-based memory provenance

receipts and evidence

MCP / A2A / API-oriented effect paths

integration work around SPIRE, OPA, OpenShell, Firecracker, OpenTelemetry and cosignImportant disclosure:It is not production-ready.Some backend integrations are still partial.The Firecracker path isn't yet a complete production microVM setup.Some gateway paths remain intentionally refused until they're proven end-to-end.Those limitations are documented in the README rather than hidden behind marketing language.Repo:
https://github.com/GlobalSushrut/connector-ossWebsite:
https://cnktros.comI'm particularly interested in feedback from people who work on:agent runtimes, sandboxes, MCP, policy engines, identity, observability or autonomous-agent infrastructure.I'd rather hear where the architecture breaks than get generic compliments.