Writing, 25 Oct 2026, 3 min read

tripline: assume something gets in, make sure it leaves with nothing

tripline is an open-source monitor for self-hosted AI systems. It catches secret access, exfiltration and stolen key use, without predicting how the attacker got in.

If you run AI systems yourself, a gateway like LiteLLM, a few agents, some MCP servers, they hold your provider keys and cloud credentials. A malicious package or a prompt-injected agent can get in, and you can’t predict how. I built tripline, an open-source monitor for self-hosted AI systems, around a different question: not how they get in, but what every attack has to do after.

The problem

In October 2026, LiteLLM was compromised. A gateway like that sits on exactly the keys an attacker wants. Most defenses try to stop the way in: scan the package, sandbox the agent, filter the prompt. Those help, but the ways in keep changing, and you only need to miss one.

What doesn’t change is what happens next. To be worth anything, an attacker has to touch your secrets, send them somewhere, and use them. Those three steps are small, loud and easy to watch, if something is watching.

What it does

tripline watches those three steps and alerts when they happen.

  • Touch secrets. Decoy files that nobody should open, and credential-file reads.
  • Send them out. An egress sensor flags connections to unknown or lookalike domains. A CONNECT to litellm.dev is denied as a lookalike of litellm.ai.
  • Use them. A stolen decoy config points at a trap. When anyone uses it, anywhere in the world, you get a critical alert that names the key to rotate.
  • Provider mode. The gateway holds no real keys, and a request that carries a foreign API key is caught.

Every alert says what happened, what was already done, what you must do, and its trace ID. It is watch-only by default: nothing blocks traffic until you set mode: enforce in a signed rule bundle.

How it works

Sensors send events to a watcher. The watcher evaluates rules, links events into chains (a secret read followed by a denied connection on the same system), writes everything to a hash-chained audit log, and sends alerts to Slack, a webhook or stdout.

Level You deploy It catches State
1 Watcher, decoys and a trap A stolen decoy config used anywhere Built
2 Egress sensor (CONNECT proxy) Unapproved and lookalike destinations Built
2 Provider mode Requests that carry a foreign API key Built
3 Falco rules, coding-agent hooks Credential-file reads, agent-config edits Planned

A security tool is a target too, so tripline is built to be hard to turn against you:

  • One static Go binary with two dependencies.
  • Signed rule bundles. Two of N Ed25519 signatures, rollback protection, and a delay before any loosening takes effect. Sensors verify each bundle themselves and do not trust the watcher.
  • Floor rules compiled into the binary. A bundle can add to them but never weaken them.
  • Hourly self-tests try to break the rules and report the pass rate.
  • Signed, reproducible releases. Cosign signatures, an SBOM, and two CI runners that must build identical binaries.

Try it

You need Go and just:

git clone https://github.com/Parthkomalwad/tripline.git
cd tripline && just build
export PATH="$PWD/bin:$PATH"
mkdir ~/tripline-demo && tripline init -dir ~/tripline-demo
cd ~/tripline-demo && tripline watcher -config tripline.yaml &

tripline init prints a sensor token once, and the paths of two decoy files. Copy the decoys to where an attacker would look. The status page runs on 127.0.0.1:7701.

See it catch an attack

The replay lab recreates the shape of the LiteLLM compromise with decoy data, on a network with no internet route. CI runs it on every change:

just replay 1            # decoy use detected at the trap
just replay 2 enforce    # lookalike connection denied, even with the watcher killed

What’s next

  • Level 3: Falco rules and coding-agent hooks for credential-file reads and MCP tool changes
  • Key-usage connectors that flag stolen keys used from new networks

The code is on GitHub, Apache-2.0 licensed. The threat model lists what tripline does and every limit. See my other work, or read about Sable, another tool built on the idea that you should see what runs on your server.

#security#agents#go#open-source

Comments

All writing RSS Reply by email