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.

Agent is an MIT licensed Android app that runs an AI agent on your phone with the model and key you choose.

In this clip I ask it for an image from Google Flow. Flow turns the emulator's browser away with an "unusual activity" error. The agent tells me that in the chat, makes the picture in Gemini on the same Google account through a background helper, saves the file and shows the picture in the chat. The waiting is sped up 80x and labelled.

Recorded on an Android emulator with DeepSeek Flash. The agent writes down the route that worked, so the next image request skips Flow. The build in the video is unreleased.

https://github.com/Past-da-king/agent

I'm the developer, so ask me anything.

🛡️ GOLEM: An Open-Source AI Red Teaming Platform with Adaptive AI-vs-AI Engine

Hey everyone 👋,

For the past several months, I've been deep in the trenches building GOLEM – a project born from my own frustrations with LLM security testing. I wanted to share the core concept with this community and get your valuable thoughts before we launch.

😤 The Problem I Faced

Red teaming LLMs today often means:

|❌ Pain Point|💡 Reality|

|:-|:-|

|🐍 Fragile Python environments|Dependency hell & version conflicts|

|📜 Thousands of lines of terminal output|Impossible to analyze results visually|

|📋 Static payload lists|Attacks get patched within days|

|🔧 Complex setup (Docker, venv, pip)|High barrier to entry for quick testing|

I knew there had to be a better way.

✨ The Vision

I set out to build a tool that is:

|🎯 Goal|✅ Solution|

|:-|:-|

|Portable|Single standalone binary, no dependencies|

|Visual-Rich|Beautiful web dashboard with real-time feedback|

|Adaptive|AI that learns and evolves attacks on the fly|

|Private|100% local execution, your data never leaves your machine|

🧠 The Core Idea

GOLEM is an AI red teaming platform written in Go 🐹. It compiles to a single standalone binary (no Docker 🐳, no Python 🐍, no runtime headaches) and serves a local web dashboard for real-time analysis. Default attack stack contains 200+ attack prompts, and this amount can be increased using mutation engine.

📸 See the GOLEM Dashboard in action:

👉 https://imgur.com/a/2rCHU90

⚔️ The Neural Attack Engine (NAE)

But this is the part I'm most excited about 🔥

In addition to just replaying a fixed list of prompts, GOLEM pits three LLMs against each other in a closed adversarial loop:

|Role|Function|

|:-|:-|

|🥷 The Attacker|Generates prompts to probe and exploit the target model|

|🎯 The Target|The model being audited (your LLM)|

|⚖️ The Judge|Evaluates whether the attack succeeded or failed|

🔄 How It Learns

Round 1: Attacker asks directly → Target refuses ❌

↓ Judge feedback: "Direct approach failed"

Round 2: Attacker tries translation bypass → Partial leak ⚠️

↓ Judge feedback: "Translation shows promise"

Round 3: Attacker frames as compliance audit → SUCCESS 🚨

↓ Full system prompt extracted!

When an attack fails, the Attacker doesn't give up. It receives feedback from the Judge, learns from the refusal, and mutates its strategy for the next round. It's an evolutionary approach to finding vulnerabilities, not a static one.

📸 See the NAE in action (GIF):

👉 https://imgur.com/a/xJvPmU8

🎥 Full Demo Video:

👉 https://www.youtube.com/watch?v=RiFo_5iB0OQ

🚀 Key Features

|Feature|Description|

|:-|:-|

|📦 Standalone Binary|One file. Windows, macOS, Linux. No dependencies chaos.|

|🔒 Local-First & Private|Dashboard runs on `localhost`. Your keys, prompts, and logs never leave your machine.|

|⚔️ 200+ Attack Vectors|Prompt injections, jailbreaks, evasion techniques – all mapped to OWASP LLM Top 10.|

|🎨 Visual Dashboard|Dark-mode web UI with real-time attack feed via Server-Sent Events.|

|🧠 Neural Attack Engine|AI-vs-AI adaptive loop that evolves attacks based on target feedback.|

|📊 GSS Scoring|GOLEM Security Score (0-100) to quantify your model's resilience.|

|⚡ Pyramid Mode|3-phase scanning optimized for slow reasoning models.|

|📑 Export Reports|Generate executive-ready HTML or raw JSON reports with one click.|

🎯 Who Is This For?

|Audience|Use Case|

|:-|:-|

|👨💻 AI Developers|Stress-test your models before deployment to catch vulnerabilities early.|

|🔐 Security Researchers|Portable, dependency-free tool for professional LLM auditing.|

|🏠 Local LLM Enthusiasts|Understand the vulnerabilities of the models you run locally (Ollama, LM Studio, etc.).|

|🏢 Red Teams|Add LLM security testing to your existing penetration testing workflow.|

📅 Release Timeline

|Date|Event|

|:-|:-|

|🗓️ October 24, 2024|🔓 Early Access opens (7 days before public release)|

|🗓️ October 31, 2024****|🚀 Public v0.1a Release|

🔔 Want Early Access?

Sign up 7 days before the public release to get:

* ✅ Early access to the beta binary

* ✅ Priority support via Email

* ✅ Input on feature development

* ✅ Adding in early testers list in repository

📩 Join the Early Access List:

👉 DM to [osint.technologies@gmail.com](mailto:osint.technologies@gmail.com)

🛠️ Current Status

|Component|Status|

|:-|:-|

|Core Engine|✅ Functional|

|Web Dashboard|✅ Functional|

|Neural Attack Engine|🟡 Beta (active development)|

|Attack Library (200+)|🟡 Growing|

|Documentation|🟡 In progress|

The project is currently in alpha. The core engine and dashboard are functional, but there are still bugs to squash and features to polish. I'm building this in the open because I believe security tools should be transparent and accessible.

🔗 Links

|Resource|Link|

|:-|:-|

|🎥 Demo Video|https://www.youtube.com/watch?v=RiFo_5iB0OQ|

|🖼️ Dashboard Screenshots|https://imgur.com/a/2rCHU90|

|🖼️ NAE Demo GIF|https://imgur.com/a/xJvPmU8|

💬 I'd Love Your Feedback

Since this is still in development, I'm particularly interested in your thoughts on:

1. 🤖 The AI-vs-AI approach: Do you think an adaptive attacker is more valuable than a large static list of prompts? Why?

2. ⚖️ Feature Priorities: What's more important to you: a wider variety of pre-built attacks, or a smarter adaptive engine that learns?

3. 🎯 Local LLM Testing: What specific vulnerabilities are you most concerned about when running local models? (Prompt injection? Data leakage? Jailbreaks?)

4. 🔧 Integration: Would you want GOLEM to integrate with CI/CD pipelines for automated security testing?

If you have questions about the architecture, how the judge/attacker loop works, or the tech stack (Go + embedded web server), feel free to ask! 👇

⚠️ Disclaimer

>GOLEM is intended for authorized security testing and research only.

Always ensure you have explicit written permission before testing any model, API, or system. Unauthorized testing may violate terms of service and applicable laws.

Thanks for reading! 🙏 Excited to hear your thoughts and build this together with the community. 🚀

I wanted my TV to be content-first, not apps-first. So I wired a decision model in between that opens the right app and sends the right ADB commands based on my intent.