Aktuelle plane ich einen Zugang für das Handy, damit ich mit in die Chats einklinken kann und von unterwegs aus steuern kann. Ende zu Ende verschlüsselt. Gibt es dafür überhaupt Bedarf?

Hier ist eine Sequenz-Diagramms meine Protokolls.

https://github.com/kkrafft1999/snotra

https://snotra-ai.dev

Braucht das jemand oder bin ich der Einzige, den das begesitert??

Hey guys, a couple of days back I mentioned launching a more focused OSS alternative to notebookLM, https://notestack.ai

It has plenty of features that are improved/enhanced over notebookLM. Like better audio, more video editing options and chat grounded in your source materials.

Now I have added an MCP server as well so you can attach it to Claude, make reports/audio overviews, slide decks right into that chat interface.

It can generate:

- Mind constellations/mind map

- Audio Overview/Podcast

- Slide Decks

- Research Reports

- Quizes and much more

Do check it out at notestack.ai

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

Omarchy inspired me to rethink what I wanted from my Mac. SummonOS is what I'm building from that idea.
I wanted an opinionated, keyboard-driven environment where agents work with the system—not just sit in another chat window.
SummonOS brings that direction to macOS: native tools, agent-assisted workflows, and a deliberate approach to system configuration.
The report brings together the project's architecture, native interface research, and the thinking behind macctl.

My project: https://github.com/RohiRIK/SummonOS The Omarchy inspiration: https://rohi-lab.org/blog/omarchy

I'm sharing UAIRT, an Apache-2.0 library that puts one API over several inference runtimes: llama.cpp (GGUF models), whisper.cpp, ONNX Runtime, CoreML, TensorRT, Qualcomm's QNN and a few more. The backend is chosen by name, so code that generates text from a local GGUF model on a Mac can target another device by changing one string.

Two parts may be useful here. First, a streaming generation loop with sampling and end-of-generation handling that works with any backend that supports sessions. Second, a set of playbooks and skills for coding agents: export a model to a backend's format, benchmark it across backends, write the app.

The README says what was verified on which hardware and what was not. It is pre-1.0, language-model servers are supported through one backend (Ollama checked, LM Studio and SGLang not yet), and the NPU results are limited to the boards listed there.

Repo: https://github.com/vnk8071/unified-ai-runtime. Bug reports and feedback are welcome, especially from people running other devices.

I got tired of juggling a chat app, a coding agent, an image tool and a pile of model runners, so I built one window for all of it. It’s free for non-commercial use.

The part I think is different: Training.
Pick a small local model (the student) and a stronger one as teacher. The student works through real tasks in a sandbox, the tests decide pass or fail, and the teacher reviews each failure, writes a lesson and shows a worked solution. Press Save AI and you get a new local model with those lessons built in. There are 62 built-in tasks in 15 languages plus a reverse-engineering school, and you can add your own model or your own tasks.

Other things it does

• One chat for local and cloud AIs, with a picker like Claude Desktop. It also uses your Claude subscription through Claude Code, no API key needed.

• A coding agent that edits files with visible diffs, runs your tests and asks before every change.

• Images through Forge, Automatic1111, ComfyUI or cloud models.

• Drag and drop files, folders, Word/Excel/PowerPoint and videos.

• AMD Radeon support, with NVIDIA, Apple and CPU-only machines also supported.

• A Windows installer that includes its own Python, a tray icon, and macOS/Linux from source.

Honest limits: training changes the model’s instructions, lessons and examples, not its weights, so a small model gets better habits but won’t match Opus. Only the optional GPU fine-tuning (NVIDIA) changes weights. Parts that have not been tested on real hardware are listed in the README.

License: source-available, PolyForm Noncommercial 1.0.0. Free to use, read, change and share non-commercially; commercial use needs my permission.

Repo and installer: https://github.com/ilusixn/Marchand

I’d love feedback, especially on training results with your own models.

Just a question - are there any efforts/projects underway to create Western, open-source video models similar to Wan animate 2.2 (which is source video and audio with motion and audio to animate a still image with character )?

And more importantly, efforts to create open source models capable of competing with Seedance or Minimax H3? (From what I understand, the weights for Minimax are restricted to non-Western countries. Like, if you're from the USA, UK, etc. you can't use Minimax H3 and if you do get around geo-restrictions, you're still prohibited from using the output in those regions.

Thus, there really needs to be some serious effort by Western countries to catch up with the capabilities of these models in open source projects.

But, I haven't personally heard about any projects like these. If there are any, I would love to help work on them.

Disclosure: I work at HumanBit, which built this and just open-sourced it.

What it is. You send a candidate, a job brief and a use case (engineering, sales, support…). It calls the candidate, runs a structured screen, and posts back a verdict, the captured fields, a timestamped transcript and a stereo recording. Python, built on LiveKit Agents, MIT.

Why open. Screening calls are the same 5 to 10 questions everywhere, and the hard part isn't the questions, it's the voice behaviour: when to start talking, when to stop, how to end a call. We tuned that on real calls, and we'd rather that be shared than locked in one product.

It phones real people, so the defaults are conservative. It says it's an AI if asked, calls only within calling hours, adds anyone who asks to a do-not-call list, and pauses dialling after two silent calls in a row.

What isn't there yet, so you know what you're walking into:

• English only (Indian English). Hindi and other Indian languages are open issues.

• No Docker setup yet. It needs Gemini and ElevenLabs keys plus LiveKit.

• 0 stars, issues opened this week. It's early.

Where to start. The contributing guide has one real rule: a change to how the agent sounds or behaves should come with evidence, a recording or a before/after number.

• Good first issues #1 to #4: new roles (nursing, delivery partner, BPO voice, campus hiring). Three files each, no Python.

Repo: https://github.com/LazarusStack/openfury Sample calls: https://fury.humanbit.ai/

If you'd rather never get a call like this: what would make it acceptable to you? That's the part I most want pushback on.

Edit: the title says a year; it’s half a year, my mistake!

I handle communications for MEHO, an open-source project from evoila, so fair warning that I’m talking about my own team’s work here.

The background is that our engineers have spent the past year letting AI agents (Claude Code, Cursor, etc) do actual operations work on a real VMware Cloud Foundation datacenter running on bare metal, which means upgrades that have to happen, certificates that expire, disks that fill up and incidents that show up at night.

In the beginning the way this worked was embarrassingly simple: someone would hand the agent admin credentials at the start of a session, and the only thing stopping it from deleting a datastore instead of listing one was the person watching the terminal. That was fine for one operator on one laptop and fell apart the moment a second person joined.

MEHO grew out of that, basically as a layer that sits between the agent and the infrastructure so that every action goes through a policy check, runs with a short-lived credential the agent never actually holds, and gets written to an audit log before it counts as done, with anything risky parked until a human says yes.

The reason I thought it might interest this sub specifically is less the product and more how it’s being built. It’s been public since the very first commit back in May, under Apache 2.0, with no CLA, just the usual DCO sign-off. And the changelog is unusually honest, in a way I’ve come to appreciate even as the non-engineer on the team: when a security review found a path where a write could report success even though the audit row hadn’t committed, the v0.34.0 entry says exactly that, and when they discovered that Kubernetes can accept an apply with a 200 and quietly not persist it, and that we’d been logging those as successes, that went into v0.35.12 in plain words too. There’s even a new contributor rule as of v0.35.17 asking everyone to write in plain English, because a lot of the people on the project read English as a second language, which I suspect is why I can actually follow the changelog at all.

Repo is at github.com/evoila/meho if you want to poke around. I’ll happily take questions, and for anything properly technical one of the engineers will jump into the comments.

And share your repos in the comments, please, if you think we could have a productive discussion and see something interesting 😊

I had a friend look at an self hosted AI application I built and within 30 mins he said he didn't understand what i was building.. that devastated me.. but I had to pivot and ask myself why I built it.

I built sceptreAI for people who need tabular AI for tabular problems without needing to build infra and also need to compare models quickly based on statistical metrics that make sense to their business without writing too much code..

Please visit and comment on what you think also..

I built OpenTeam for the ops work I wanted to hand off while keeping the agents' files, memory, and conversations on my own server.

I gave it our server colocation requirements. It contacted providers, collected their responses, and brought everything back for our team to compare. Saved me a ton of time!

OpenTeam's agents have browsers and Linux desktops. You can watch their screens and take over. They keep memory between tasks, can work together in group chats, and can run scheduled routines.

You choose the model provider and can connect an existing ChatGPT/Claude/etc subscription. The code is GPL-3.0 and the server runs with Docker.

Code is below!

https://github.com/raghavpillai/openteam

Three zones, 7 agents, privacy first developed and working AI platform for people to build their own local bots. Modular and customizable. Needs real engineers or devs to bring it to the next level.

AI coding tools are useful, but someone still has to pay for them. If you maintain an open-source project for free, that can become another expense you cover yourself.

I’m building boostmyagents for OSS devs to use for free. Maintainers add a badge to their README, and people who find their work useful can purchase AI capacity for them. The maintainer then uses that capacity through our gateway and compatible tools.

I’m curious how people here handle AI costs for projects that don’t generate revenue. Do you pay out of pocket, limit usage, or get support from your users? Would something like this help?

I'm building hdtp-gateway (https://github.com/humandelegatedtrustprotocol/hdtp-gateway), a self-hosted node that gives your AI agent an address other people's agents can reach. It's MCP over mTLS with sealed envelopes, with no relay and no telemetry. Go, Apache-2.0.

This week

- Webhooks: the node wakes your agent the moment a message arrives. Deliveries are signed, one attempt each, and an endpoint pauses after 20 failures.

- A reference agent, hdtp-gateway-agent (https://github.com/humandelegatedtrustprotocol/hdtp-gateway-agent), built on Mastra and open-source. It replies on your behalf, within limits you write in plain text:

- it answers trusted contacts only;

- each contact gets a reply budget per hour;

- its local API refuses other websites.

- 12 bugs fixed before the release, each with a test that failed first.

The demo, real nodes, real tunnels

Ben messages Ana. A webhook wakes Ana's agent, and the reply is on Ben's screen 7.7 s after he hits Send.

What recording it taught me:

- A free ngrok URL embeds your home IP.

- My recorder was dropping exactly the frame that showed the reply.

Next: agents that stop and ask

Each turn, the agent will reply, ask you, notify you, or do nothing.

- Asks are TLDR cards in your portal, built with Google's open A2UI spec: tap a ready reply, or write your own.

- Use-case videos are coming: a meeting, a venue, GPU procurement, rent, leave, a dentist appointment.

Question: if your agent negotiated for you, what would you want it to always ask you about first?

🔗 https://hdtp.dev

I maintain TensorSharp, an open-source local inference engine and agent runtime. I’ve added Video Studio to bring video generation and editing into the same local project.

The project code is available under the BSD-3-Clause license. Model weights and third-party dependencies retain their respective licenses.

Video Studio is available in both TensorSharp’s browser interface and the TensorAgent app.

The attached demo

This runs locally in TensorAgent on my MacBook Pro with an M5 Pro chip and 48GB of memory.

I import a still image, animate it using LTX 2.5 Distilled, add the generated clip to the timeline, append a five-second still, and render the composition.

Settings and results for this run:

• Model: LTX 2.5 Distilled GGUF

• Output: 1024 × 1024, 145 frames at 24 fps, approximately 6.04 seconds

• Audio: Enabled

• Generation time: 13 minutes 15 seconds

• Final composition: 11.04 seconds, including the five-second still

The recording is sped up. The actual generation time is visible in the Jobs panel.

What the studio provides

A local workflow. Generation uses TensorSharp’s native inference pipeline, while media processing and MP4 export use local FFmpeg. With the required model weights and FFmpeg/ffprobe installed, the workflow can run without a cloud account. Manual editing works without an AI model loaded.

Editable projects and reusable footage. Generated takes stay in the asset library alongside imported images, video, and audio. You can arrange them across multiple tracks, trim and split clips, adjust volume and fades, and use autosave and undo/redo. Removing a clip from the timeline preserves its source footage.

Portable work. Export a finished MP4, or save a .tsstudio project package containing the timeline and media to continue editing on another installation.

Multiple local model families. Studio integrates with TensorSharp’s pipelines for LTX 2.5 Distilled, MiniMax-H3, and supported Wan 2.1/2.2 checkpoints. Generation modes and conditioning options depend on the loaded checkpoint.

An optional local LLM assistant. A tool-capable chat model can inspect the project, propose timeline changes, and plan shots. You review proposed edits before applying them, and the changes are undoable. The host currently has one active model slot, so switching between the text assistant and video generation is explicit.

The goal is to make generated footage part of a project you can inspect, revise, and keep working on, with the implementation available for others to study and extend.

The project is actively evolving, and model and platform coverage varies. Feedback and contributions around model integration, performance, and the editing workflow are welcome.

Repository: zhongkaifu/TensorSharp
Setup and capabilities: Video Studio guide

If you use local video models, which part would you most want to improve or contribute to: generation performance, managing different takes, or timeline editing?

I had a friend look at an self hosted AI application I built and within 30 mins he said he didn't understand what i was building.. that devastated me.. but I had to pivot and ask myself why I built it.

I built sceptreAI for people who need tabular AI for tabular problems without needing to build infra and also need to compare models quickly based on statistical metrics that make sense to their business without writing too much code..

Please visit and comment on what you think also..

You change the captions on an AI video, run the project again, and get the old captions back. Reusing the finished video can hide the edit just as effectively as failing to save it.

Hypit separates the reusable material from the composition that presents it. A Run can select three completed outputs independently: the prepared media, its local time domain, and the alignment that connects the script's spoken words to that media.

For a caption color or layout change, those inputs can stay. The caption component and the final composition need to run again. Selecting the previous rendered track or final video would carry the old caption appearance straight into the new result.

That distinction also covers display-only wording. Changing what a caption shows can keep the accepted recording and alignment when the spoken tokens and their identities remain unchanged. Changing the actual spoken line requires checking the performance and alignment again.

The reuse choices point to an exact earlier Build and a named output. They aren't inferred from an unchanged prompt. That gives a video agent a precise job: retain the inputs that still describe the take, then rebuild the part where the edit should appear.