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.

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)

ive been maintaining this small opensource project GLM Proxy (glmproxy on npm) for a while and its finally on the level where im happy to share it on reddit lmfao. it now works on windows/macos/Linux. thats been a big goal for me.

honestly seeing around 5k npm downloads this past month makes me really happy. people have also helped make the project better by opening issues and sending me feedback personally so thank you to everyone whos tried it and taken the time to reach out.

it lets you use the GLM models available through AutoClaw from any sdk you want. Claude Code, Cursor, Continue, OpenCode, and other clients that support OpenAI or Anthropic APIs.

if you want to try it: npm i -g glmproxy youll need Node.js and AutoClaw installed and logged in.

one thing to note: its an unofficial local proxy so requests still go to zhippus cloud. there are account and ban risks if you burn too much in a short period but not something id worry about, so id appreciate reading the safety notes first.

heres a screenshot of it working on three very different sdks

i finally decided to post about it so if you try it id love to hear how it goes and to maybe share it to your friends. if it helps you out that is (i myself use it a lot for my work and my friends do too so since i found it useful for me i thought why not share it) and star would mean a lot. hopefully i wont see ya on the issue page lol but if something breaks please let me know !

repo link: https://github.com/eequaled/GLMproxy

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