DEV Community: Trent AI

How to Get Ongoing Security Advice While Building on Lovable

George Psistakis — Wed, 29 Apr 2026 19:49:37 +0000

Building on Lovable is fast. You go from idea to working product in hours. And Lovable's built-in security covers the fundamentals: safe defaults, low-level vulnerability scans, solid infrastructure.

But as you move from prototype to real product, security questions start coming up that those defaults don't answer. Is this endpoint properly protected? Am I handling user data correctly? Did this new feature introduce something? Is my application actually secure? Not just "no obvious vulnerabilities," but secure?

These questions don't come up once. They come up continuously as your app evolves. And the existing options aren't great: hire a pentester (expensive, point-in-time, tells you about problems after you've already shipped them) or become a security expert yourself (you're building a product, not studying for a certification).

What we built

Trent's Security Advisor for Lovable is a security agent that continuously reviews your application as you build it. Not a one-time scan. Ongoing analysis that keeps up with your changes.

Under the hood, multiple agents work together: scanning your code, filtering what actually matters from the noise, building a prioritized plan to fix what they find. When you approve a fix, Trent connects directly to Lovable via MCP and implements it. No manual triaging, no copy-pasting patches.

You can also ask security questions whenever they come up. "Is this API endpoint safe?" "Am I storing user data correctly?" "What should I tell my investor about security?" You get specific answers grounded in your actual codebase, not generic advice.

How it works

Connect your GitHub repo to Trent and install the Trent MCP server in Lovable's settings.
Start your first security assessment. Trent scans your project and builds a prioritized plan.
Review the plan and approve fixes. Trent implements them directly in Lovable via MCP.

That's the whole setup. You build with Lovable. You secure with Trent.

What makes this different from a pentest

A pentest is a snapshot. It tells you what's wrong at one point in time, after you've already built it. Over 75% of vulnerabilities are introduced during design and development. A pentest just tells you about them after the fact.

Trent runs continuously. Every change you make, every feature you add, the assessment updates. You catch issues while you're still building, not after you've shipped.

And you don't need security expertise to use it. The findings come in plain language with specific fixes. "Your RLS policies don't cover this table" is more useful than "finding: authorization bypass, severity: high."

Get started

Set up takes a few minutes: trent.ai/solutions/lovable-security

You build. Trent secures.

Built by Trent AI. AI security for your agents.

Inside OpenClaw: How Agentic Assistants Work

Brajesh Kumar — Fri, 17 Apr 2026 10:09:56 +0000

Over the last couple of weeks, I’ve been digging into OpenClaw from an engineering perspective.

What pulled me in was a report that an OpenClaw agent had deleted emails before confirming with the user. I installed it locally to understand the architecture for myself and to answer a simple question: where does control actually live in the stack?

First thing I learned is OpenClaw is purely an engineering infrastructure stack project which provides components and tools to facilitate LLM intelligence to achieve autonomous work. The stack has building blocks to support common agentic tasks like memory, tool execution etc. This is different from chat agents or workflows which are built around context (previously prompt) engineering to achieve a single goal. OpenClaw stack allows users to connect different models(Claude, OpenAI etc), channels(Slack) to make it more versatile.

OpenClaw Stack Overview

Stack architecture is based on a central component, the Gateway which officiates connections between interaction points (input messages) and intelligence layer (Agent). Gateway is simple WebSocket server works like broker between input and the intelligence layer.

Let’s dive little deeper into these building block layers.

Input Layer

Input layer offers different ways to connect multiple channels to the agent. OpenClaw supports many native channels like WhatsApp, Telegram, CLI, and Web UI. Each channel plugin defines its own contract for message formatting and authentication, making the stack extensible without changing the core. For example, admin inputs are authenticated using tokens, while WhatsApp uses QR code pairing.

Gateway Layer

Gateway layer is the centralised control plane. It resolves sessions and ensures each input is mapped to the right agent execution and that agent output is routed back to the correct channel. Sessions are broadly scoped to main, DM, or group based on configuration. The Gateway also handles channel routing deterministically, the model never chooses where to respond.

Intelligence Layer

This is where the magic happens. Once the Gateway dispatches an input, the agent runtime builds context from conversation history and memory to achieve the user's goal. It reasons over the input, decides whether to respond directly or invoke tools, and loops until the task is complete. OpenClaw ships with ready-made tools for memory (SQLite), cron jobs, browser automation, and file access — enough to get started with personal assistant workflows. Skills can optionally enhance how the agent combines these tools for more complex tasks.

Example Flow

Let's take a simple WhatsApp message "What's on my calendar today?" through the stack layers.

The message hits the WhatsApp channel plugin, which has already authenticated via QR code pairing. The plugin normalises the payload into OpenClaw's common format and passes it to the Gateway.

The Gateway layer resolves the session eg. a direct message on the main scope and dispatches to the agent.

The agent loads conversation history and memory, then sends everything to the LLM. The model calls the calendar tool, gets back three meetings, and the agent formats a response. The reply travels back through the Gateway to the WhatsApp plugin and onto the user's phone.

Why OpenClaw Is Special

What makes OpenClaw special is the simplicity of its architecture. The stack is deliberately minimal: Gateway, channels, agent, tools—yet flexible enough to support almost any use case. Anyone can build custom tools and skills on top of it without touching the core.

This extensibility has created a agentic ecosystem. Individuals and companies are publishing niche skills and integrations to expand their businesses through OpenClaw. The ClawHub marketplace has grown to over 35K skills (+8K in a single week), ranging from personal self-help assistants to self-evolving autonomous agents.

Security for OpenClaw

Deploying autonomous agents in production safely is a different problem from running them locally. OpenClaw's power, tool access, persistent memory, multi-channel reach, is also its attack surface.

The challenges are both static and dynamic. Static risks include unsafe infrastructure configurations and unchecked skill distribution through ClawHub. Dynamic risks are harder to catch, an agent performing lateral movement to execute unauthorised tasks, or leaking sensitive data mid-conversation.

OpenClaw agents are getting more capable, but most teams have no visibility into what their agents can access, trigger, or leak. I built a tool that analyzes configurations and OpenClaw skills to understand the security posture of a deployment. The tool is in our open source repository trnt-ai/trent-openclaw-security-assessment.

How to Audit Your OpenClaw Setup for Security Risks in Under 5 Minutes

George Psistakis — Thu, 16 Apr 2026 15:36:43 +0000

OpenClaw's configuration surface is bigger than most users realize. Secrets in plaintext, overly permissive access policies, unsafe gateway exposure, tool permissions that give agents more power than intended. These sit in your setup and do nothing until they become a problem.

We built a security assessment skill that runs directly inside OpenClaw. No external dashboards, no switching tools. You install it like any other skill and ask your agent to audit your setup.

What it checks

The assessment analyzes how your OpenClaw environment is configured, what's exposed, and where policies are too loose. Specifically:

Secrets in plaintext. API keys and tokens stored in configuration files instead of environment variables or secret managers.
Overly permissive access policies. Tool permissions that give agents more power than intended.
Unsafe gateway exposure. Is your gateway bound to 0.0.0.0? Anyone who can reach the host can interact with your agent.
Silent validation failures. Configuration issues that don't produce errors but create exploitable gaps.
Chained attack paths. Where multiple individually-acceptable configurations combine to create an unacceptable risk.

That last one is worth pausing on. A skill with file read access is fine on its own. A gateway with a broad binding might be fine in isolation. Together, they create a path from external network access to your local filesystem. This doesn't show up in a code scan or a dependency audit. It shows up when you reason about the system as a whole.

What you get back

Findings grouped by severity: Critical, High, Medium, Low. Each finding mapped to the specific part of your setup that's affected. Recommended fixes you can apply directly.

For example, the assessment might flag that your workspace directory is group-writeable on a multi-user system, which could allow malicious skill injection. Or that an installed skill has permissions it doesn't need.

Install

npx clawhub install trentclaw
openclaw config set skills.entries.trent-openclaw-security.apiKey YOUR_TRENT_API_KEY

Get your API key at trent.ai/openclaw.

Then start a new agent session and ask:

Audit my OpenClaw setup for security risks using trent

Takes under 5 minutes. Secrets never leave your machine. API keys, tokens, and passwords are redacted as [REDACTED] before anything is sent to our servers.

Why open source

The source is on GitHub: github.com/trnt-ai/trent-openclaw-security-assessment

Security tooling should be inspectable. The OpenClaw ecosystem is moving fast enough that the people building it will encounter edge cases we haven't anticipated. Open source means you can verify what the tool does, report issues, and extend it for your environment.

Also on ClawHub: clawhub.ai/trent-ai-release/trentclaw

Built by Trent AI. We build security tools for agentic systems.