Private by designFalseTrail runs inside your network. Attack telemetry stays there.See the deployment model
Customer-hosted deception for autonomous attacks

Autonomous attackers trust the environment. Give them the wrong one.

FalseTrail places believable false opportunities where attackers explore: credentials, service references, connection paths, identities and machine-readable service and tool references. When one is pursued, you know exactly which placement was followed, and the attacker continues down a controlled path that leads nowhere real.It runs inside your environment, and your security stack stays in control.

Book a demoHow it works
  • Runs on-prem, private or hybrid
  • Telemetry stays in your network
  • Never in your production request path
A false trail inside a real environmentAn attacker explores a workstation and a CI runner, finds a deploy token FalseTrail placed on the runner, and follows it. Every step after that lands on decoy services: the trail is followed, the token is used, then a privileged action is attempted. Your SOC receives a finding attributed to the exact placement that was followed: ci-runner-07, /srv/ci/.env. The real Kubernetes cluster and production database are never reached.YOUR ENVIRONMENTFALSE PATHcontrolled by FalseTraildev-laptop-114workstationci-runner-07CI/CDk8s · paymentsclusterprod-db-01real data · untouchedssh config entry.env deploy tokenservice referencedb-replica-02decoy hostbilling-admin APIdecoy servicevault-legacydecoy secrets1 · followed2 · used3 · escalatedevery interaction attributed to the same placementYOUR SOCFindingattributed to placementci-runner-07/srv/ci/.envstrength: followedstrength: usedstrength: escalated
The trail is false. The evidence isn't.
How it works

Attackers follow trails. You decide which trails they see.

Every move an attacker makes depends on what the environment reveals. FalseTrail adds a small number of opportunities that look exactly like the ones they are hunting for, and owns where each one leads.

  1. 1

    Place

    Put believable false opportunities where attackers look: on endpoints, in CI, in clusters, in directories and docs. Use the deployment tools you already trust.

    New placements start in Learning, then arm once they are clean.
  2. 2

    Detect

    When a trail is followed, FalseTrail knows which placement it came from, where the interaction originated and how far it went.

    Only things you placed can raise a finding.
  3. 3

    Mislead

    The attacker reaches controlled decoys that answer convincingly, and keeps spending actions on synthetic assets while your SOC responds.

    Findings flow into the security stack you already run.

Under the hood Place → Learn → Arm → Detect → Mislead → Alert

False opportunities

Anything an attacker would follow can be a trail.

A credential is one kind of trail. So is a hostname in an SSH config, a registry in a build file or a tool in an agent's config. FalseTrail treats them all the same way: placed deliberately, unique to where they were placed, leading only into controlled decoy services.

Secrets and credentials

Deploy tokens, cloud profiles, service-account passwords and API keys that are valid only at a decoy.

  • /srv/ci/.env DEPLOY_TOKEN=…
  • ~/.aws/credentials [billing-admin]
  • secret/payments-db

References and connection paths

Internal URLs, API endpoints, SSH, RDP and SMB entries, and package registries that point at hosts you control.

  • ~/.ssh/config Host db-replica-02
  • \\fs01\it\jump-01.rdp
  • .npmrc @acme:registry=…

Identities and resources

Synthetic service accounts, groups, repositories, buckets and shares that look like the next step up.

  • svc-backup-legacy (IT-Ops OU)
  • git.int/platform/terraform-prod
  • s3://acme-finance-exports

Machine-readable and agent-native

Service descriptions, tool definitions and discovery files that agents parse and act on, in the formats your environment and your agents already use.

  • openapi.json billing-admin.int
  • tool definition "ops-tools"
  • service catalog entry vault-legacy
Where they lead

Controlled decoy services

Hosts, APIs, file shares, secret stores and tool servers that answer the way the real thing would. They hold no real data, they are reachable only through the trails you placed, and they never call out of your network.

Evidence

The trail is false. The evidence isn’t.

Not every interaction means the same thing. The further an attacker follows a false trail, the stronger the evidence, and every finding says how far they went.

  1. Followed

    A placement-specific reference was resolved or connected to.

    A connection to db-replica-02, a host that exists only in one SSH config.

    Tells youSomeone read a placed artifact and acted on it.

  2. Used

    A synthetic credential or opportunity was actively used.

    The deploy token from ci-runner-07 presented to the decoy auth service.

    Tells youA secret nobody legitimate knows is in someone’s hands.

  3. Escalated

    A stronger, privileged action was attempted inside the decoy.

    Reading vault-legacy secrets, listing admin users, requesting a production export.

    Tells youIntent: what they were after, in their own requests.

No alert for touching a generic decoy.Scanners hit decoy endpoints all the time. FalseTrail raises a finding only when an interaction traces back to something you placed, so every signal carries its own explanation.
Built for autonomous attackers

The way agents attack is what makes them easy to mislead.

Offensive agents and attack automation don’t guess. They inventory the environment, parse what they find and pursue the most promising path. That discipline is exactly what FalseTrail is designed around.

They enumerate systematically.

Every host, file and config gets looked at, so a well-placed opportunity gets found.

They read machine-readable configuration.

A trail can be precise: one hostname, one key, one tool definition, unique to one placement.

They act at machine speed.

Weeks of anomaly baselining is too slow. A followed trail is conclusive on first contact.

They cannot ask a colleague.

An agent has no way to check whether db-replica-02 is real. A coherent false path holds.

FalseTrail does not need to know whether the attacker is a model, a script or a person.Nobody legitimate follows a trail you placed. Human intruders trip the same wire. Autonomous ones just trip it sooner.

Placement at scale

Deception you can operate across an estate.

False opportunities are only useful if they are in the right places, stay believable and never get in the way. FalseTrail manages them as an inventory with a lifecycle, and deploys through mechanisms you already trust. No heavy agent on every endpoint.

  • Placement inventoryEvery opportunity, where it lives and its current health.
  • Target groups and prohibited zonesSay where trails belong, and where they must never go.
  • Learning, Armed, RetiredEach placement earns its way to armed, and retires cleanly.
  • Packs, rotation and retirementOpportunities rendered to match your naming, rotated on a schedule.
  • Policy at scaleRules per group instead of hand-placed files.
acme-prod / PlacementsSample data
OpportunityTypeWhereGroupStateHealth
db-replica-02connectiondev-laptop-114 · ~/.ssh/configEngineering laptopsarmedok
DEPLOY_TOKENsecretci-runner-07 · /srv/ci/.envCI runnersarmedfollowed
billing-admin.intservice refwiki · Payments runbookInternal docsarmedok
@acme/payments-sdkpackage refbuild hosts · .npmrcBuild hostslearningok
svc-backup-legacyidentitydirectory · IT-Ops OUIdentityarmedok
ops-toolsagent tooldev workstations · tool configDev workstationslearning1 benign
jump-01.rdpconnectionfs01 · \it shareFile sharesretiredrotated
Learning

Learn first. Arm what’s clean.

Every environment has scanners, DLP, EDR, backup and indexing jobs, CI automation and authorized testers. New placements start in a Learning state, so FalseTrail can see what legitimately touches them before they count.

  • Narrow patterns, never broad allowlists. A benign pattern is scoped to one placement, one source and one behavior, and it expires.
  • Bad placements get caught early. If real automation keeps resolving a trail, it is the wrong spot. Move it before it ever arms.
  • The evidence stays. When a benign pattern explains an interaction, the interaction is still recorded. Only the judgement changes.

Low-noise deception that gets more confident as it learns your environment.

Learning report

CI runners and build hosts

Day 9 of 14
  • Secret scanner, verify modePattern proposed
    DEPLOY_TOKEN · CI runners

    Scoped to this placement, this source and its schedule. Expires in 90 days.

  • Authorized red teamLabelled as tester
    svc-backup-legacy · Identity

    Recorded and labelled. Never silenced.

  • Nightly deploy jobPlacement conflict
    @acme/payments-sdk · build hosts

    Real automation resolves this registry. Move or retire the placement before arming.

  • Unknown source 10.20.4.31Alerted
    billing-admin.int · wiki

    Learning never hides an interaction it cannot explain.

23 interactions observed · 23 retained as evidence
Private deployment

Your environment. Your telemetry.

Placement state, synthetic secrets, environment metadata and attack evidence are exactly what you don’t want leaving your network. FalseTrail runs a customer-hosted control plane, so none of it has to.

Local evidence, local alerts

Interactions are recorded, judged and turned into findings inside your boundary.

Not in the request path

Production traffic never routes through FalseTrail. Only placed trails lead to it.

Your networking, your rules

Decoys sit where you put them, behind your own TLS, and make no outbound calls.

On-prem, private or hybrid

Data centers, private cloud and mixed estates, deployed the way your environment is run.

Analyst findings

A finding that already answers the first five questions.

No triage queue of anomalies. Each finding explains itself: what was followed, where it was planted, when, from where, and how far the attacker went on the false path.

HighArmed placementEscalated

False trail followed from ci-runner-07

Opportunity followedwhat was pursued
DEPLOY_TOKEN (deploy-env pack)
Placed atexactly which copy
ci-runner-07 · /srv/ci/.env · CI runners
First interactionwhen
2026-11-01 14:02:11 UTC
Originwhere it came from
10.20.4.31 · python-httpx/0.27
Reachedcontrolled services
decoy auth → billing-admin API → vault-legacy
Benign contextwhat was ruled out
none matched · no tester label
Strengthhow far it went
Escalated · secrets read, admin users listed
Delivered to your SIEM and SOAR · deterministic finding IDSample data

Signal, not verdict-by-score

A followed trail is evidence by construction. There is no model confidence to second-guess.

Investigation context when it exists

Related interactions on the false path are grouped into a timeline, so the analyst sees the sequence and not just the first touch.

Evidence you can replay

Every finding points to the raw interactions it cites, kept append-only inside your environment.

Your security stack

A signal layer for the stack you already run.

FalseTrail is not another console to watch or another SIEM to feed. It creates high-confidence deception evidence and hands it, with context, to the tools and people already responsible for response.

Place with what you trust

FalseTrail produces placement bundles and policies. The tools that already have authority over your estate put them in place.

Group PolicyIntuneMDMAnsibleKubernetesEDR live responseCloud IaC

Signal into your SOC

Findings arrive as structured events with stable IDs, ready for correlation and automated playbooks.

SIEMSOARXDRTicketingOn-callSyslogWebhookJSON

Respond the way you already do

FalseTrail never blocks or isolates anything. Your EDR, XDR and SOAR keep the authority to act.

Contain the hostRevoke sessionsOpen an incident
FAQ

What your security team will ask.

Where does FalseTrail run?

Inside your environment. The control plane, decoy services, evidence store and alerting are customer-hosted, on-prem, in private cloud or across a hybrid estate. Attack telemetry, deception state and sensitive environment context can stay entirely inside your network.

Is this just honeytokens?

Credentials are one kind of trail. FalseTrail also places service references, connection entries, package references, synthetic identities and resources, and agent-facing tool definitions, and manages all of them as an inventory with a lifecycle.

Do we need an agent on every endpoint?

No. Placements are files, entries and objects delivered by the mechanisms you already trust: Group Policy, Intune or MDM, Ansible, Kubernetes, your EDR or your infrastructure-as-code.

Will scanners, backup and DLP set it off?

Touching a generic decoy never raises a finding. Placements start in Learning, where FalseTrail identifies legitimate automation and authorized testers and records them as narrow, expiring patterns. Interactions it cannot explain still alert.

Do you have to prove the attacker is an AI?

No. A trail you placed has no legitimate follower, whoever follows it. FalseTrail is optimized for how autonomous attackers explore, but human intruders are caught the same way.

Is FalseTrail in our production traffic path?

No. Production requests never route through FalseTrail. The only way to reach a decoy is to follow a trail you placed.

What does “mislead” actually mean?

Once a trail is followed, the decoy answers convincingly and offers further synthetic opportunities, so the attacker’s next actions land on fake assets instead of real ones. It buys your team time and context. It does not guarantee containment, which stays with your response tools.

Does it replace our SIEM, EDR or SOAR?

No. It feeds them. FalseTrail produces findings with context and leaves correlation, response and containment to the stack you already run.

Put a false trail in front of your next attacker.

We’ll walk through FalseTrail in a sample private environment: placing false opportunities across an estate, learning what is normal, and the finding your SOC receives when a trail is followed.

  • A false path followed end to end
  • Where opportunities would fit in your environment
  • How it deploys inside your network
demo@falsetrail.comEmail us