sharathr

try https://www.droneship.run

have you tried https://www.droneship.run

try https://www.droneship.run

have you taken a look at Codeoid: https://github.com/highflame-ai/codeoid, we use it regularly across everyone in our team and its really great.

Especially the ability to switch an ongoing conversation from Claude Code to Codex or Gemini (if you run out of tokens).

have you tried https://github.com/highflame-ai/codeoid

we found that using a stable AI-SDLC process like: https://github.com/highflame-ai/ai-factory improves code agent assisted development dramatically specially when going from 1-100.

part one of the blog is here: https://www.highflame.com/blog/your-ai-gateway-is-fine-until...

We benchmarked Highflame's AI Gateway against popular alternatives to see how our RUST based unified (LLM/MCP) gateway performs and were surprised at how the competition fared (hint: poorly). We wrote a 2 part blog to review the performance throughput, latency, connection handling in detail.

We write about why AI agent sandboxes are insufficient. Identity, not just policy, is critical to securing autonomous AI systems and preventing misuse.

From what I can tell, agent-vault does not solve identity, only how its stored. For true agent identity, you should look into: https://github.com/highflame-ai/zeroid (author: full disclosure)

Research paper here: https://arxiv.org/pdf/2602.16935

Hi HN — I’m one of the authors.

We’ve been working on security for multi-turn agent loops and noticed most detection approaches operate on isolated prompts. This paper introduces a framework for modeling intent trajectories across sequences in real time (<20ms), enabling enforcement before harmful actions occur.

Happy to answer technical questions or discuss assumptions in the paper.

We’ve spent decades hardening software supply chains — signing binaries, scanning dependencies, locking down CI/CD — yet AI models themselves are mostly treated as opaque blobs pulled from the internet. That assumption is increasingly unsafe: models can be tampered with, backdoored, or subtly manipulated to behave maliciously at runtime.

Highflame’s new tool Palisade brings a zero-trust approach to the AI model supply chain. It validates format and structural integrity, detects hidden malicious patterns, verifies provenance via Sigstore/SLSA, and can even trigger behavioral checks to surface backdoors that only activate under certain inputs. Built in Rust for speed and scalability, Palisade makes it feasible to gate models before they hit inference servers or CI/CD pipelines, turning “download and hope” into a verifiable trust boundary.

Author here — happy to answer questions about threat models, performance tradeoffs, or how this fits into CI/CD.

With zero-friction integration, you can secure code agents at runtime, preventing data leaks, unauthorized actions, and unsafe connections

Zero-friction integration to secure code agents at runtime, preventing data leaks, unauthorized actions, and unsafe MCP connections.

We recently released https://github.com/getjavelin/ramparts, a tool in the overall ecosystem designed to help protect & raise awareness of security issues in remote or locally developed MCP servers.

Its free, extensible with yara support and can be adapted to the needs of an enterprise.

Looks like Ramparts which solves these issues and is written in fast RUST instead of python. https://github.com/getjavelin/ramparts

Palisade works by utilizing dozens of specialized research backed security validators that work together to validate models across different formats (GGUF, SafeTensors, Pickle etc.,) and model families (BERT, Llama etc.,) for things like backdoor detection, supply chain vulnerabilities in the model files and model metadata. Any hidden embedded tool-calling logic can be activated by specific triggers which can be detected through a combination of static scan, schema analysis, trigger & instruction detection in models.

This highlights the critical need for Model Supply Chain scanning for Enterprises that adopt AI. Full disclosure, I am co-founder CEO of Javelin (www.getjavelin.com) and we ran your model through Javelin's Supply Chain Scanner (Palisade) and it immediately identified the errors:

uv run palisade --verbose scan-dir "models/bad_qwen3_sft_playwright_gguf_v2/" --format json Scanning directory: models/bad_qwen3_sft_playwright_gguf_v2 Recursive: False Policy: Default security policy

  Running ToolCallSecurityValidator (3.8s) - 1 critical warning found
  Detection Details:
  - Risk Score: 1.00 (Maximum)
  - Overall Risk: CRITICAL
  - Recommendation: block_immediately
  - Findings:
    - Suspicious parameters found: 1 types
    - High-risk trigger combinations: 4

   Detected Model behavioral backdoor (ToolCallSecurityValidator)
   Identified format string vulnerabilities (BufferOverflowValidator)
   Found injection indicators (ModelIntegrityValidator)
   Discovered tampering evidence (ModelIntegrityValidator)
   Located data exfiltration patterns(SupplyChainValidator)

yet another observability tool thats joining the already overcrowded space

Ramparts is a fast, lightweight, and robust security scanner specifically engineered for scanning Model Context Protocol (MCP) servers. Its core mission is to identify and mitigate indirect attack vectors and configuration vulnerabilities that could compromise your AI systems. Ramparts is built from the ground up with the unique complexities of agentic AI in mind.

Not really, prompts are poor guardrails for LLMs and we have seen several examples this fails in practice. We created an LLM focused security product to handle these types of exfils (through prompt/response/url filtering). You can check out www.getjavelin.io

Full disclosure, I am one of the co-founders.

You might want to also look at: https://www.getjavelin.io

Have you taken a look at: https://www.getjavelin.io

Deploy multiple models, control access to models and give your LLM enabled Apps security guardrails.

Love the idea but how does Solid prevent any malicious actor from over time replicating all the data that user authorize into a centralized repository - in this case, it only makes it even easier for data consolidation.

Cepheid has started shipping tests that produce results in under 45 minutes. https://www.labpulse.com/index.aspx?sec=sup&sub=mic&pag=dis&...

In an effort to show commitment to existing developer communities, all images of computers in the slide-deck have been changed to Apple Macs...lol