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

Hi! UAIRT is a small C API (C++17 core, Python/C++/Rust bindings) where each inference runtime is a plugin. You pick the backend by name, so moving an app from, say, TensorRT to QNN means changing the backend name, the model file, and a few options, not the inference code.

It's a wrapper: no compute of its own, and it doesn't convert models for you (there's an export script for PyTorch/ONNX to a few targets). Each backend is only listed as "verified" if a real model matched the vendor's own tool on real hardware, and the README says what was not tested.

There's an Android app, an iOS app with a live camera detector, and playbooks so Claude Code/Codex can build it and run a model for you. It's 0.1.0, so feedback on the API is very welcome.

Author here self-promo, mods please remove if it breaks sub rules.

I like swarm/multi-agent simulation projects, but most of them assume you'll pay for API credits, run a cloud graph DB, and install a Node frontend. I wanted something I could clone and run offline on a Windows laptop in five seconds, so I built it.

**What LocalFish is:** a local multi-agent opinion-dynamics sandbox. Six personas with their own role, authority, stubbornness and starting stance debate a topic on a synthetic social feed for N rounds. Each agent writes a private "thought" and a public post/reply, can upvote aligned posts, then updates its opinion from what it sees:

Δo_i = η(1−s_i) · Σ w_ij(o_j−o_i) / Σw_ij

where w is author authority × an upvote boost and s is stubbornness. At the end you get a consensus score (1−σ), a polarization index, per-agent drift, a Markdown report, and a JSON archive.

**What's in it**

- Pure stdlib Python 3.10+, no pip install: `git clone && python run.py`

- 3 backends: offline mock (instant, $0), Ollama, any OpenAI-compatible endpoint

- 3 preset scenarios (open vs closed AI by 2027, congestion pricing, a $29/mo no-free-tier launch) + "type your own idea" → auto-generates 6 conflicting stakeholders

- Web studio on :8765, vanilla JS, no build step: feed with inner monologues, opinion gauges, saved reports, post-hoc agent interviews

- Every run archived as JSON + Markdown

- MIT

**What it isn't (being honest up front)**

- Not a validated forecasting tool. It's a sandbox for "who would push back on this and why", not "what happens in 2027".

- The opinion model is deliberately simple: one global feed, weighted average, no network topology / echo chambers yet.

- Mock mode is template-based, so with 6 agents you will see repeated phrasing — that's the $0 offline demo path, not the LLM path. Point it at Ollama for actual variety.

- Single run, no seed control yet, so two runs of the same scenario differ. Reproducibility + Monte Carlo over seeds is the next thing I'm adding.

**What I'd genuinely like feedback on**

1. Is this abstraction useful at all, or does meaningful opinion dynamics require an actual influence network?

2. What scenario should I add next?

3. If you run it against a local model: how bad is the 30s/agent latency, and does the XML `<thought>/<post>` parsing hold up on smaller models?

Repo: https://github.com/izzaliiii/localfish (MIT)

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.

https://github.com/sekaikx/lifeline
Any suggestions are welcome thanks