Skip to content
Tabya siftha.com

Continuous threat modeling

Draw your architecture. The threats follow.

Works without AI. Hosted or on your own servers, more than one way to run it is planned. Turn AI on when you want it.

Made for software architects and security architects, working on one model in one place.

See how it works In production
Web shop
An illustrated example built from Tabya's own rules. Attack paths are planned for the next stage and shown here as a preview.

Who it's for

Software architects and security architects, on one model.

The architecture is the model. Whoever draws the system and whoever works the threats look at the same drawing, and when it changes, both see what changed.

Software architects draw

The system the C4 way: context, containers and components, with zones and trust boundaries. Tabya suggests the links; you confirm them and answer a plain question or two about each part. No threat framework to learn first.

Security architects work the threats

One list, worked out from that drawing: each threat with its severity, its place on the canvas and its STRIDE, ATT&CK, CAPEC and CWE labels. Decide on each one, and the decision stays with the model.

One drawing, one picture

There is no separate threat diagram to keep in step. Change a part and the threats follow, a decision that relied on it is marked for review with the reason, and the change summary says what moved, in words both of you read.

One person at a time, for now

The core is built for one person on one model. Sign-in and accounts come after it, and this page will say when they do.

Why Tabya

A threat model should keep up with the system it describes.

Four things Tabya does today, and what is planned next, marked as such.

Draw your architecture, not a diagram for threat modeling.

The drawing is the model. Context, containers and components on a C4 canvas, with zones and trust boundaries. The threats are worked out from it; there is no second diagram to keep in step.

Fewer false alarms by design, and what it can't tell yet is kept apart.

Tabya asks before it accuses. A plain question settles what a drawing can't show, and only confirmed links produce threats. What it can't decide yet goes on a "To check" list, outside the threats and outside every count. False positives are measured on Tabya's own reference architectures.

Works without AI, and nothing leaves your machine.

Every threat comes from Tabya's own rules. The same drawing and answers always give the same result. Today it runs on your machine with no telemetry and no outside calls. AI is planned as something you turn on, never something the engine needs.

Change the drawing, and it tells you what changed.

Tabya reacts. Add, change or remove a part and the threats follow: new ones arrive, unrelated ones stay put, and a decision that relied on a fact that changed is marked for review, with the reason. Every edit gets a short summary.

"Unless the stencils are configured correctly, it is very easy to have tons of false positives."The maker of Tabya

Next, and marked Next wherever it appears on this page: sign-in, roles and shared editing, so a software architect and a security architect work on one model; then attack paths, an OSI layer lens and daily vulnerability checks.

A diagram drawn once

Drawn for a review, by hand, in a tool made for threat modeling. Every threat it lists was true the day it was drawn. The architecture moves on; the diagram doesn't. Six months later the question is which of its findings still hold, and nobody can say without drawing it again.

A model that follows every change

Drawn as the architecture, in the shape architects already use. A new part brings its own threats, a removed one takes them away, and a decision that rested on something that changed is marked for review with the reason. The question six months later is answered by the change history, not by a redraw.

How it works

Three steps, and then it keeps watching.

Software architects and developers draw the architecture. The threat model is worked out from it, never drawn by hand, and security architects work it on the same drawing.

  1. 01Draw

    Context, containers and components on a C4 canvas, with zones and trust boundaries. Tabya suggests the links; you confirm or dismiss them, and dismissed ones don't come back.

  2. 02Answer

    One plain question at a time about each part: does it need a sign-in, is its data encrypted? No framework to learn first.

  3. 03Threats

    One list, each threat with its severity, its place on the drawing and its framework labels. Decide on each, and the decision is kept.

  4. 04React

    Every change gives a short summary of what it added, closed or put up for review, and the history shows how the model grew.

What it does

Built in stages, each one usable.

The core is being built now, and it needs no AI. Working together, the views, the optional AI and the live data come after, in this order.

The core

Building now
  • A C4 canvas at the Context, Container and Component levels, with zones and trust boundaries.
  • A stencil box of types first and products on top: cloud services, on-premises parts and business software.
  • Suggested links with direction and protocol, which count only once you confirm them.
  • One threat list from Tabya's own rules, labelled STRIDE, ATT&CK, CAPEC and CWE.
  • Decisions that last, flagged for review when a fact they relied on changes, and a change summary for every edit.

The live data

Later
  • Daily vulnerability checks from public sources, matched to the versions you give.
  • A larger stencil box, with the long tail of products.

Planned: the OSI lens

An OSI layer view on the same drawing.

Choosing a protocol for a link fills in its layers. Pick a layer and Tabya lights its parts and links and filters the threats. The lower layers of cloud and SaaS parts are run by the vendor, so they raise no threats of yours.

LayerOrders API, yoursPayments, SaaS 7ApplicationHTTPHTTP 6PresentationTLSTLS 5SessionTLSvendor-run 4TransportTCPvendor-run 3NetworkIPvendor-run 2Data link—vendor-run 1Physical—vendor-run

A preview of a planned view. Which layers a protocol fills is Tabya's catalogue's call.

Method and limits

What the rules see, and what they don't.

A threat list is only as good as what it was worked out from. This is what Tabya's rules read, where they stop, and what its numbers mean.

They see what you drew

The parts, the zones and trust boundaries, the links you confirmed, and the answers you gave. A link Tabya suggested and you didn't confirm counts for nothing.

They don't see what you left out

Today Tabya reads no source code, no repository, no cloud account and no running system. A part that isn't on the canvas raises no threat, and a protection you didn't draw or declare isn't credited.

Unknown is not no

A rule fires only on what is known. An unanswered question never raises a threat and never silences one: the check waits on the "To check" list, outside the threats and outside every count, until you answer it.

The numbers are Tabya's own

Its false-positive figures come from its own reference architectures, drawn for the purpose, some of them scored before the rules had seen them. No other tool was measured on them, so they say how Tabya does on its own test set, not how it compares with anyone else.

Built to be trusted with your architecture

Your drawing is confidential. Tabya treats it that way.

Its own engine

Every threat comes from Tabya's own rules. The same drawing and answers always give the same result, with no AI needed. AI is planned as something you turn on, never something the engine relies on.

Nothing sent anywhere

No telemetry and no calls to outside services. The first stage runs on your own machine, with fonts and icons inside the app.

More than one way to run it

Today it runs on your own machine. A hosted service and an edition installed in your own network are both planned; which ways are offered, and on what terms, isn't decided yet.

Measured, not promised

False positives are counted on Tabya's own reference architectures, including ones the rules were never tuned on. The test set is the measure, not a comparison with any other tool.

Questions

What architects ask before they draw anything in it.

Is AI required?

No. Every threat comes from Tabya's own rules, and the same drawing and answers always give the same list. AI is planned as something you turn on, for help with the drawing and for a match when a product's vulnerability data is missing. Left off, nothing is missing from the threat list.

Does my drawing leave my machine?

Not today. The first stage runs on your own machine, sends no telemetry and calls no outside service; the fonts and icons are inside the app. A hosted way of running it is planned, and before one is offered this page will say what it means for where your model is kept.

How will I run it?

More than one way is planned: as a hosted service, or installed on your own servers. Which ways are offered, and on what terms, isn't decided yet. Today it runs on one machine, for one person.

When does it open?

It's in production, built by one person, and there is no date. This page will say when it opens. There is no waiting list, because this page collects nothing, not even an email address.

Can my software architect and my security architect work on it together?

Not yet. The core is one person on one model, in one browser. Planned next: sign-in, roles and shared editing come before attack paths, so that the two of them work on the same drawing, each in their own role.

A tabya is a small fort built ahead of the main line of defence.

Threat modeling does the same: it puts the defence in front of the attack, while the system is still a drawing. The mark is drawn from the eye and hook motifs of Anatolian kilims.

Status

Tabya is in production.

It's being built by one person at Siftha, from public methods and its own rules. It isn't open yet, and this page will say when it is.

Back to siftha.com