Lobster Trap

Lobster Trap is a reverse proxy built by Veea that sits between AI agents and any OpenAI-compatible LLM backend. It performs deep prompt inspection (DPI) on both incoming prompts and outgoing responses, classifying threats and enforcing YAML-based firewall rules in sub-millisecond time using compiled regex patterns. No additional model calls, API keys, cloud connectivity, or runtime dependencies are required.

General
Release date	18 Feb 2026
Developer	Veea
Type	Open-source LLM security proxy
License	MIT
GitHub	veeainc/lobstertrap
Documentation	README and policy reference

Core Features

Regex-based DPI - all classification runs in sub-millisecond time using compiled regex patterns, with no secondary LLM calls for threat detection.
Bidirectional inspection - rules apply to both incoming prompts and outgoing responses, catching both injection attempts and exfiltration in responses.
Structured metadata extraction - detects and surfaces intent categories, risk scores, credentials, PII, system commands, injection attempts, exfiltration patterns, target paths, domains, and risky commands.
Programmable YAML policy - first-match-wins ingress and egress rules with actions: ALLOW, DENY, LOG, HUMAN_REVIEW, QUARANTINE, and RATE_LIMIT.
Declared vs. detected intent - agents can declare intent via _lobstertrap request headers; Lobster Trap compares declared against detected and reports mismatches in the audit trail.
Real-time dashboard - built-in web UI at http://localhost:8080/_lobstertrap/ showing live traffic, decisions, and metadata.
JSON-line audit logs - structured logs of every decision, readable by security tooling or a regulator.
Drop-in deployment - transparent proxy for any tool using the OpenAI chat completions API; no application code changes required.

Supported Backends

Lobster Trap works with any OpenAI-compatible inference endpoint:

Backend	Notes
Ollama	Default target in quickstart config
vLLM	Compatible via OpenAI-compatible API
llama.cpp	Compatible via server mode
OpenAI	Proxy to production OpenAI API
Anthropic	Via OpenAI-compatible adapter
Gemini	Via OpenAI-compatible adapter

Policy System

Policies are defined in YAML and loaded at startup. Each rule specifies a direction (ingress or egress), a priority, match conditions, and an action.

Available actions:

Action	Behavior
`ALLOW`	Pass the request through
`DENY`	Block and return an error
`LOG`	Allow but write a log entry
`HUMAN_REVIEW`	Flag for manual review queue
`QUARANTINE`	Isolate for deferred inspection
`RATE_LIMIT`	Throttle matching traffic

A default policy file is provided at configs/default_policy.yaml as a starting point. Rules also support network policies and filesystem restrictions in addition to content-based matching.

Tools and Resources

GitHub repo (MIT) - source code, issues, and contribution guide.
README and quickstart - full policy reference and setup instructions.
Default policy - configs/default_policy.yaml in the repo, ready to fork and extend.
Adversarial test suite - run ./lobstertrap test to validate your policy against built-in attack patterns.
Single-prompt debugger - run ./lobstertrap inspect "<your prompt>" to see full metadata extraction output for any input.

Deployment Options

Three ways to run Lobster Trap:

Standalone - clone the repo, run make build, then start with ./lobstertrap serve. Requires Go 1.22 or later.
Pre-built static binary - download a Linux, Windows, or macOS binary from the repo with no Go toolchain required.
Native.Builder - already packaged inside lablab's Native.Builder environment; no setup needed.

No API keys, signups, rate limits, or cloud dependency required for any deployment path.

Ecosystem and Integrations

Acts as the trust layer beneath multi-agent systems, enforcing per-agent permission boundaries and logging cross-agent interactions.
Serves as a foundation for compliance policy packs targeting HIPAA, SOC2, or financial regulations.
Integrates with governance dashboards and drift monitoring tooling via its structured JSON audit log output.
Supported by Veea engineers in the lablab Discord for policy review, integration help, and architecture questions during hackathon build phases.

Get started by cloning the repo and running ./lobstertrap serve, or download a pre-built binary from github.com/veeainc/lobstertrap. The full policy reference is in the README.

Fresno LUX: A Living City

Fresno LUX is a prototype for a living intelligence layer across an entire city. Fresno already contains enormous amounts of intelligence: residents know where problems exist, nonprofits know where help is needed, businesses know where opportunities exist, educators understand gaps in learning, researchers generate knowledge, and government maintains critical infrastructure and data. The problem is that much of this intelligence is fragmented across disconnected systems. Fresno LUX connects those pieces. The platform creates a shared city graph where people, organizations, resources, needs, projects, observations, experiments, and outcomes become connected nodes. Instead of simply collecting data, LUX continuously asks: What is happening? What do we know? What is missing? What can we test? What changed? A community problem can become an observable signal. That signal can become an experiment. The experiment produces evidence. Evidence changes the system's understanding. That updated understanding informs the next action. Observe → Connect → Understand → Act → Measure → Learn → Converge. The goal is to move Fresno from disconnected information toward collective intelligence—a system where knowledge can travel across boundaries and successful solutions can be discovered, tested, measured, and replicated. LUX is designed to make the invisible connections visible: the relationship between a neighborhood and its resources, between a student and educational opportunity, between a business and workforce capacity, between environmental conditions and community health, and between an idea and measurable real-world impact. This hackathon prototype demonstrates the beginning of a Living Fresno Graph: a city that can observe itself, learn from evidence, and coordinate toward better outcomes.

YAYA — Wheel Strategy Trading Agent

YAYA is a fully autonomous options trading agent built on Alpaca's paper trading infrastructure. It implements the wheel strategy — selling cash-secured puts on liquid underlyings, then transitioning to covered calls if assigned — without any manual intervention during market hours. The agent runs a continuous decision loop: it checks market hours via Alpaca's clock endpoint, fetches the live option chain using the Alpaca CLI, selects the nearest-expiry put with a real bid within a defined strike distance, passes the candidate through deterministic risk gates (position size cap, buying power check), and submits a limit sell order through the Alpaca Trading API. Every decision — submitted, blocked, or errored — is logged to a CSV with timestamp, symbol, strike, bid, and reason. Risk gates are a first-class citizen of the design, not an afterthought. The agent will not trade if the notional exposure exceeds the position cap or if buying power is insufficient — and the log proves it. Built solo in Python. Uses Alpaca CLI for chain exploration and quote fetching; alpaca-py SDK for order execution and account management. No external dependencies beyond the Alpaca stack.

Phalanx

The Problem: Modern enterprise LLM pipelines are blindly trusting external web data, leaving them vulnerable to sophisticated prompt injections and context manipulation. Current security solutions rely on recursive LLM-based filtering, which is both latency-heavy and computationally expensive. The Solution: Phalanx AI acts as an immutable air gap. By leveraging the Band SDK, we orchestrate a decentralized swarm of specialized agents. Our pipeline follows a rigid interrogation order: Ingestion (Bright data SERP): Bypasses 403 blocks via rotating proxies. Deterministic (Regex): Filters known threats instantly. Statistical (Math): Our custom Stats Agent uses Shannon Entropy and cryptanalytic formulas to identify obfuscated/encoded payloads in sub-milliseconds without burning API tokens. Semantic (Gemini): Deep behavioral analysis intercepts logic traps. Compaction (Llama-70B): Only safe, cleared data is distilled into a compact JSON format for your core model. Extra Protection: Phalanx integrates Lobstertrap, an MIT-licensed Go-based edge inspection engine, ensuring structural integrity at the lowest level. Phalanx is model-agnostic, scalable via Google Cloud Run, and engineered to enforce deterministic security over unpredictable generative AI.

ATLAS - Enterprise Multi-Agent Governance

ATLAS is an enterprise multi-agent system where every agentic decision is inspected, signed, and auditable. THE PROBLEM Goldman Sachs CIO said publicly: "We don't know what controls we need for agentic AI." Enterprise LLM agents make decisions affecting databases, APIs, financial records. There is no infrastructure that makes these decisions inspectable, auditable, and compliant. WHAT ATLAS DELIVERS - 29/29 scientific test suite PASS in under 1 second - All 5 sponsors integrated end-to-end (real API calls, not mocked): · Speechmatics for voice transcription · Featherless for open-source model routing (MiniMax-M2.5, DeepSeek-V3.2, Kimi-K2.5, Llama-3.3-70B) · Google Gemini 2.0 Flash for orchestration and synthesis · Vultr for infrastructure layer · Kraken for financial action layer - SOUF AI DPI inline governance: every prompt inspected in 0.079ms avg (well under 1ms ceiling) - Ed25519-signed audit chain with SHA-256 Merkle tamper-evidence - 8 signed records per full pipeline request, chain verified - Isaac Adams (Featherless judge): "confidence is what enterprise AI needs" — ATLAS is that confidence layer ARCHITECTURE 6-layer governed pipeline: Voice → Speechmatics → SOUF AI DPI gate → Gemini orchestrator → Featherless router → Tool executor (Search/Database/Kraken/Vultr) → Ed25519 audit trail → Gemini synthesis. REPRODUCIBILITY git clone https://github.com/SRKRZ23/atlas cd atlas && pip install -r requirements.txt python3 src/test_atlas.py → 29/29 PASS in under 1 second ECOSYSTEM ATLAS is the routing layer of a 4-product AI safety ecosystem: SOUF AI provides DPI, FORGE generates policies, CITADEL evaluates models, ATLAS calls them all. Same Ed25519 audit chain across four products. MIT licensed. Lobster Trap is the floor. ATLAS is the agent governance ceiling. Built solo by Sardor Razikov, Tashkent.

CXGuard - Powered by Lobstertrap

CXGuard is a security gateway and governance dashboard for AI-powered customer support agents. It is designed for companies that want to deploy AI support bots safely without exposing themselves to prompt injection, customer data leakage, refund abuse, secret extraction, policy manipulation, or unsafe automated actions. As more customer experience teams adopt AI agents to answer questions, resolve tickets, process returns, and reduce support costs, a new class of risk appears. Unlike traditional software, AI agents can be manipulated through language. A malicious customer may try to override the agent’s instructions, reveal hidden system prompts, extract private customer information, access internal policies, bypass refund limits, or trick the bot into performing actions it should not take. For enterprises, these failures are not just technical bugs — they can become privacy incidents, financial losses, compliance gaps, and reputational damage. CXGuard solves this by sitting between the customer support interface and the underlying language model. Every support conversation is routed through Lobster Trap, an inline prompt inspection and policy enforcement layer, before the request reaches the LLM. Lobster Trap inspects incoming prompts and outgoing model responses for risky signals such as prompt injection, credential extraction, personally identifiable information requests, sensitive file paths, role impersonation, unsafe commands, external exfiltration, and other suspicious patterns. CXGuard then turns those low-level security signals into an enterprise-ready product experience: clear decisions, risk scores, policy hits, incident details, human-review queues, and audit-ready logs.