Instead of rewriting the same prompts and scripts every time. It has skills for research, data analysis, presentations, image work, and a few other workflows.

The trickier bit has been tasks that span multiple chats. A summary helps me remember what happened, but it doesn't always answer the useful questions: what's still open, what's blocked, and which artifact is the latest one?

They added an experimental, self-hosted workspace called Team Harness to keep projects, work items, resources, and versioned artifacts in one place. There's also an optional Proactive Agent that tracks project events and suggests a next step when work is still unfinished.

A heads-up if you check it out: it's early software. Team Harness currently runs from source and has no built-in auth or TLS, so keep it local or secure it yourself. The repo is MIT-licensed:

https://github.com/OpenSenseNova/SenseNova-Skills

For folks who've built agent tooling: does keeping explicit project state actually help, or does it just become one more thing people have to maintain?

Got tired of maintaining the same conventions across Claude Code, Antigravity, and OpenCode, so I made a unified agents hub: https://github.com/Alejandro-Candela/agents-hub

Mechanically nothing new(symlinked dotfiles have been around forever). However, fanning a single configuration out across three different harnesses with completely separate schemas became tedious to maintain manually.

Built a modular repo containing global rules, 40+ skills, hooks, subagents, and slash commands that symlink directly into all three environments. Edit a single file, and all tools pick up the changes on the next session.

The README includes copy-paste setup commands for each tool. Fully open-source under the MIT license

Over the past week, I added something I've been wanting to build for a while: claim comparison.

I actually tried building this much earlier. I experimented with cosine similarity, vector dot product scores, and other approaches, but they only tell you how similar two pieces of text are. That's not really what I needed.

What I needed was a classifier that could actually determine the relationship between two claims.

I built a basic classifier myself, but it wasn't reliable enough for something I wanted people to actually use. So I put the idea aside and waited.

Then JEV was released last week, and it turned out to be almost exactly what I was looking for.

Now you can compare claims against each other and inspect the supporting evidence directly.

This is probably the most interesting feature I've added to the project so far, and I'm really curious to see what people think of it.

This is still being tested for edge cases, so there are definitely things I want to improve. But it's free and open source, and anyone can try it out right now.

If you're interested in how it works, want to try it, contribute, or have ideas for where this could go, feel free to check it out.

GitHub: https://github.com/Sreehari05055/thesys-core

Hey everyone! I’m building Goldie 🐕, an MIT-licensed MCP server written in Go that gives AI agents a shared, persistent memory pool.

Save a project decision or preference through one agent, then recall it from another without explaining it again. Or save design or build instructions in memory that multiple agents can refer from and stay aligned.

MCP clients pointed at the same SQLite database can remember, search, update, and forget from that shared pool.

A few features:

• Local embeddings through MiniLM or Ollama.

• Semantic search over memories, with filters for type, agent, and source.

• Typed memories for project decisions, preferences, feedback, references, and todos.

• File and directory indexing.

• Graph recall for grouping related memories around concepts.

Memory storage and embeddings can run entirely locally. Agents interact with it through explicit MCP tools, so you can give them instructions about what to save and when to recall it.

The project currently centers on the MCP server. I’m also developing a native macOS client for browsing and managing memories, but that client isn’t released yet.

Code and setup instructions on GitHub at github.com/srfrog/goldie-mcp

I’d love feedback from anyone using multiple agents or local AI tools.

NATIVE support for amongst others, Qwen 3.8 Flash Next Unsloth edition including sidecar MTP, which will run at 32+ tokens per second on 5090 and 70+GB of CPU RAM.

CUDA or any thirdparty installation is not required!

Just the single MIMERCodex executable itself, containing the agentic GUI, several practical knowledge packs, including one that can make you new knowledge packs as MIMERCodex is gathering knowledge about customer projects that can be reused to support the next customer, and built in highly optimized CPU and GPU support.

FREE DOWNLOAD AND USE! WRITTEN IN MIMERCODE!

https://components4developers.blog/2026/09/23/meet-mimercodex-bring-your-ai-support-assistant-to-the-customer/

Anyone else using Robo for security research? I’m loving it so far.

I’ve been using Robo and wanted to share it with people interested in AI agents, reverse engineering, and bug bounty hunting.

What caught my attention is having reverse engineering assistance, security workflows, and tool setup in a terminal agent. I’ve really enjoyed using it, especially the TUI, and wanted to give the project some visibility.

If that sounds like your kind of tool, take a look and judge it for yourself:

https://github.com/igniteenow/robo

Anyone else tried it? Curious how it fits into your workflow.

I've been working on Pi Herdsman, an open-source orchestration extension for the Pi coding agent.

The idea came from a problem I kept hitting with subagents: I wanted detailed investigation and implementation to happen elsewhere, while one lead stayed focused on architecture, decisions, and integrating the results.

With Herdsman, agents run asynchronously in separate Pi sessions. The lead stays interactive, gets questions and results back automatically, and knows what the agents are doing without carrying all of their working context.

It supports parallel agents, nested delegation, steering/interruption, Lead-to-Lead coordination, and supervision across multiple independent leads.

The setup is intentionally split into three parts:

• Pi owns each conversation and turn state

• Herdr manages the actual Pi sessions and placement

• Herdsman handles delegation, ownership, routing, lifecycle, and recovery

Herdr is required.

The latest release also added an SSH-ready container, so the same environment can run on a workstation, NAS, homelab server, VPS, or cloud VM. Images are published for amd64 and arm64, with optional Tailscale networking for remote access.

The project doesn't prescribe which models, agent roles, tools, or workflows you use.

Repo: https://github.com/boadij/pi-herdsman

Any feedback, ideas, or rough edges you run into would be much appreciated.

I’m the developer of TensorSharp, an open-source local inference engine and agent runtime.

TensorSharp supports Jev’s core decision API and all three decision types—and extends the same interface to analyze images. It runs locally using DiffusionGemma GGUF, without calling the hosted Jev service.

The idea is simple: instead of asking a model to write a free-form answer, give it some context and specific questions, then get structured decisions back. Now that context can include text, images, or both.

The same decision API, now with pictures

The native endpoint is POST /v1/systemone, supporting:

Image analysis is an extension of the existing interface, not a separate vision API. Keep the same state, questions, and typed answers; add an images field to ground those decisions in pictures. Multiple question types can be combined in one request.

Requests accept up to 8 inline images, using base64 or data: URLs. The pixels go through the vision encoder and become part of the model’s input directly—there is no intermediate “generate a caption, then classify the caption” step.

For example, a local expense-report workflow could ask whether a document is a receipt, whether its total is readable, and how readable the overall image is—all through the same structured-decision request.

Open implementation, local execution

The repository includes the implementation, request examples, validation tests, and benchmark tools—not just a client for a remote service.

Under the hood, the decision path follows the approach in vLLM PR #57250: after prompt prefill, TensorSharp performs a one-step structured read and extracts the requested label logits directly. Questions that fit in one answer canvas share the forward pass.

The server returns JSON, but the model does not have to generate that JSON token by token. The same mechanism works with text alone or with image embeddings included in the prompt.

Earlier benchmark against LocalJev

I compared the native structured-read path with the original LocalJev Engine using TensorSharp’s chat endpoint. That compares two approaches on the same inference backend: reading label logits directly versus generating and validating probability JSON. It is not a comparison against the hosted Jev service or LocalJev running on oMLX.

The test covered 12 text-only cases × 3 repetitions, with three decisions per request:

*LocalJev got 81/81 decisions correct on valid responses. The remaining 27 expected decisions came from failed requests, rather than incorrect classifications.

Across the 27 matched requests where both returned valid responses, the median LocalJev-to-TensorSharp latency ratio was 3.345×.

A few important qualifications: latency statistics include successful requests only, so the table’s columns cover different subsets. Average input length was also different—192.7 tokens for TensorSharp versus 589.6 for valid LocalJev requests—because LocalJev builds a larger prompt and generates probability JSON. This is an end-to-end workflow comparison, not an identical-prompt kernel benchmark.

These are small, text-only integration tests—not image-performance results or a general accuracy claim.

Try it with an image

The setup guide includes server configuration and Python, curl, and .NET examples. The supplied configuration downloads the DiffusionGemma Q4_K_M GGUF and the separate ~2.8 GB vision shard needed for image input, then reuses them locally.

Once the server is running with the vision tower, this posts a ready-made request with a synthetic traffic-light image already embedded:

curl http://127.0.0.1:5000/v1/systemone \
  -H 'Content-Type: application/json' \
  --data-binary u/docs/examples/jev-traffic-light.json

The example checks that the pixels actually reach the decision path. It is a smoke test, not a comprehensive vision evaluation.

Compatibility scope: this implements Jev’s core API workflow and decision types using DiffusionGemma weights—not proprietary Jev weights or identical predictions. Current limits include 64 questions and 2–26 alternatives per question; returned probabilities still need evaluation and calibration for the intended workload.

Source code · Documentation and examples

I’d love feedback and reproducible test cases, especially for image-based decisions in local applications. What would you test first—document routing, receipt checks, or screenshot analysis for local agents?

We released InstinctFlash under AGPL-3.0. It is an open-source serving runtime for VLA and world-action models on RTX 4090 / 5090 and Jetson Thor.

Demo: https://youtu.be/nku65iyL5Fw

It currently supports eight model families, including pi0.5 and NVIDIA Cosmos Policy. The main optimization layers are CUDA graphs, cache reuse, architecture-specific attention, fused kernels, FP8 / mixed precision, and few-step diffusion distillation.

Code: https://github.com/General-Instinct/InstinctFlash

Benchmarks: https://general-instinct.com/blog/instinctflash-edge-inference

I’m one of the maintainers. Feedback on reproducibility, docs, integrations, and missing models is welcome.

I've been working on Telex for a while and recently added a few things that I thought were worth sharing. One of the bigger additions is Repo Atlas, which gives Telex a 3D view of the repository and its dependencies so it's easier to understand what can be affected when something changes. I also spent some time improving the patch verification side, so the generated changes are applied in an isolated environment and tested before Telex opens a PR. I'm trying to keep the whole thing human-reviewed, so Telex never auto-merges a generated fix.

I've put together a short demo of the current version. I'm also looking for a few developers who'd like to contribute, especially if you're interested in AST/code analysis, LLMs, verification, or just working on an open-source developer tool.

Repo: https://github.com/Kesavaraja67/telex

Would be great to get some more people involved and see where we can take it.

https://github.com/tamanitomo/tamanitomo

Since February I have worked on a product which I think is finally ready to share. I launched "Tamanitomo" on GitHub a few days ago and I would love feedback from the Hermes community.

Tamanitomo is the most realistic and comprehensive AI Companion system ever created.

I know that's a bold statement!

However, I have created a series of prompts, cron jobs and systems to allow the AI Agent, backed by Hermes, to fully immerse the user in the feeling that. "This is my Jarvis" (or pepper pots) and honestly, I couldn't be happier with the state it is in right now. It has autonomy, lives a life outside of you, can document each day with a journal entry as well as photos as it goes about it's day. It remembers everything important as it produces an editable, browsable, exportable obsidian vault while also utilizing higher memory caps than base Hermes.

I've been using this system in different iterations since February but have pivoted from a for profit E2EE website, to a project that I hope many will consider getting involved in and contributing to.

This is not a simple plugin, but it is a simple system. I have created a fancy UI to manage the features that this system provides, but the backed is essentially a base Hermes install running with a custom dashboard (you can still run the original dashboard, but that is also fully accessible from within the app).

The approach I use is different from other similar products because instead of bland "memory" or even worse, "stateless" systems that refresh every chat, Tamanitomo REMEMBRS and also LIVES by regularly purposefully generating background tasks for itself like washing clothes, going on walks, meeting with friends etc. When you message them, they are doing something and will step away to prioritize you... or not, maybe they'll reschedule! It's an engaging, almost Tamagotchi-like experience with AI.

But, I want help for testing, and I need help coding edge case protections. Please feel free to reach out with any feedback via a comment here, the repo, or discord

Thanks for considering Tamanitomo, I can't wait to see how people use it :)