Skip to content
Tabya

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

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: sign-in, roles and shared editing, so a software architect and a security architect work on one model; then attack paths and an OSI lens. Their previews on this page are marked Planned. Daily vulnerability checks come later.

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

From the first box to the change review, on one model.

A web shop with an AI assistant, step by step. The software architect draws it; the security architect works its threats on the same drawing. Steps 7 to 9 are planned, shown as previews.

Web shop
  1. 01Draw

    Software architect

    Draw the system the C4 way: people, containers and, where you want them, the components inside, placed in zones and trust boundaries. Each part is a type from the stencil box, AI agents and MCP tool servers included.

    ContextContainerComponent
    PersonBrowser appService or APIDatabaseIdentity providerAI agentTool serverExternal systemZoneTrust boundary
  2. 02Link

    Software architect

    Tabya suggests the links between parts, with direction and protocol filled in. Confirm each one, or dismiss it and it won’t come back. Only confirmed links count.

    • Customer → Web shop HTTPSsuggestedconfirmed
    • Customer → Sign-in OIDCsuggestedconfirmed
    • Web shop → Orders API HTTPSsuggestedconfirmed
    • Orders API → Orders SQLsuggestedconfirmed
    • Staff → Assistant HTTPSsuggestedconfirmed
    • Assistant → Order tools MCPsuggestedconfirmed
    • Order tools → Orders API HTTPSsuggestedconfirmed
    • Order tools → Orders SQLsuggesteddismissed
  3. 03Answer

    Software architect

    Then one plain question at a time, on the part it’s about. Answer yes, no or I don’t know: an unknown never raises a threat and never silences one.

    Orders APIService or API

    Must callers prove who they are first?

    YesNoI don’t know
    OrdersDatabase

    Is the data encrypted when stored?

    YesNoI don’t know
    AssistantAI agent

    Does a person confirm each action that changes, sends or deletes something before it happens?

    YesNoI don’t know
  4. 04Threats

    Security architect

    One list from Tabya’s own rules, each threat on its part of the drawing, with its severity and every framework label that fits. The AI agent’s threats also carry MITRE ATLAS and OWASP IDs.

    • High
      Anyone can call this without signing inOrders API · Spoofing, Elevation of privilege
      T1190CAPEC-115CWE-306
    • High
      Sensitive data unencrypted when storedOrders · Information disclosure
      T1005CWE-312
    • High
      Other people’s text can make the AI model actAssistant · Elevation of privilege, Tampering
      AML.T0051.001AML.T0053LLM01LLM06ASI01ASI02CWE-1427
    • Medium
      One caller can overload thisOrders API · Denial of service
      T1498T1499CAPEC-125CWE-770
    • Medium
      No cap on AI model use per person or taskAssistant · Denial of service
      AML.T0034AML.T0029LLM10CWE-770

    Labels: MITRE ATT&CK (T), CAPEC, CWE; on AI parts also MITRE ATLAS (AML), OWASP’s LLM list (LLM) and agentic list (ASI).

  5. 05Decide

    Security architect

    Decide on each threat: planned, mitigated, accepted or not applicable, with a note where one is needed. Each decision remembers the facts it relied on.

    • High
      Anyone can call this without signing inOrders API
      planned
    • High
      Sensitive data unencrypted when storedOrders
      planned
    • High
      Other people’s text can make the AI model actAssistant
      planned
    • Medium
      One caller can overload thisOrders API
      planned
    • Medium
      No cap on AI model use per person or taskAssistant
      acceptedNote: “Staff only, a few dozen chats a day.”
  6. 06Change

    Software architect Security architect

    The shop adds Payments and opens the assistant to customers. Every edit gets a short summary of what’s new, and a decision whose facts changed is marked for review, with the reason.

    1. Added Payments. 3 new questions, 1 suggested link. No decisions affected.
    2. Confirmed Orders API → Payments. 3 new questions. No decisions affected.
    3. Answered “Has someone checked that this party may receive this data?” on Orders API → Payments: No. 1 new threat. No decisions affected.
    4. Added Customer → Assistant. 2 new questions. 1 decision needs review.
    Needs review No cap on AI model use per person or task

    Assistant, accepted. “Can anyone on the internet reach this?” on Assistant changed from no to yes.

  7. 07Attack paths

    Planned

    Paths from anything an attacker can reach first to what you mark as most important, along confirmed links only, each step backed by a threat. Ranked, and worked out again when the model changes.

    PlannedThe highest-ranked path
    Customer→Web shop→Orders API→Orders
    1. Orders API: Anyone can call this without signing in
    2. Orders: Sensitive data unencrypted when stored
  8. 08OSI lens

    Planned

    A layer lens on the same drawing: pick a layer and see its parts, links and threats. Choosing a protocol fills in the layers of its link.

    PlannedLayer
    7 Application654321

    Payments is run by its vendor, so its layers 1 to 5 raise no threats of yours.

  9. 09Together

    Planned

    Sign-in, roles and shared editing come next, so the software architect draws while the security architect works the threats, on one model.

    PlannedShared editing
    Software architectdrawing Payments
    Security architectdeciding on “No cap on AI model use per person or task”

    Today one person works on a model at a time.

An illustrated example built from Tabya’s own rules, questions and framework labels. Some answers are given beforehand, and the counts in the summaries are illustrative. Steps 7 to 9 are planned and shown as previews.

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, MITRE 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, roles and shared editing are next, and this page will say when they arrive.

What it does

Built in stages, each one usable.

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

The core

Built, in testing
  • A C4 canvas at the Context, Container and Component levels, with zones and trust boundaries, and a Code sketch if you want one.
  • 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, MITRE ATT&CK, CAPEC and CWE.
  • AI systems drawn like any other part: AI apps, agents, MCP tool servers, model services and agent memory, their threats also labelled MITRE ATLAS and OWASP’s lists for LLM and agentic apps.
  • Decisions that last, flagged for review when a fact they relied on changes, and a change summary for every edit.
  • Example models to open and try, from a hair salon’s bookings to an AI support assistant.

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

The same drawing, one OSI layer at a time.

Choosing a protocol for a link fills in its layers. Pick a layer and Tabya highlights 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. Tabya’s catalogue decides which layers a protocol fills.

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

The threat list is worked out by Tabya’s rules alone, so the same drawing and answers give the same list every time. No AI sits in that loop; the AI that is planned is something you turn 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 it model AI agents and MCP servers?

Yes. AI apps, agents, MCP tool servers, model services and agent memory are parts you draw like any other, and Tabya’s own rules find their threats, such as other people’s text steering what an agent does. Those threats also carry MITRE ATLAS and OWASP IDs. Tabya itself runs no model to do this.

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 göz and çengel, 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