Skip to content

Features

Everything you need to get a rule right

Author in words, formulas, or diagrams, over Boolean inputs, numbers, categories, scales, counts, and scores. Check every case exactly. Explain it in plain language, test it like code, keep its full history, export it to the tools your team already uses, and build on it through the API.

Author

Words, formulas, and diagrams on one model

Every view edits the same typed model, so the plain-English source, the formula, and the gate diagram can never quietly drift apart. Move a gate and only the layout changes; rename an input and every reference follows.

Starting from words? Describe the rule and AI drafts a formula, a glossary, and the questions it couldn’t settle. The draft stays unconfirmed until you say it means what you meant.

The Natural language tab with the source rule “Allow entry when a person is a member or has an invitation, including both, provided the person is not banned”, a language and Decision rule selector, a Draft formula with AI button, and the interpretation marked unconfirmed with a Confirm the interpretation button, beside the matching gate diagram.

Draft from four languages

Write rules in English, French, German, or Spanish, in Decision or Argument mode. Ambiguity comes back as concrete choices: for “A or B and C” you see (A OR B) AND C, A OR (B AND C), and a case where they differ.

Three notations

Programming (AND, &&, !), mathematical (∧ ∨ ¬ → ↔), or textbook (A·B, A+B, overbars, indexed minterms). They all compile to the same model, and AB is always one name, never a hidden AND.

An editable gate canvas

Inputs, constants, and every supported gate, with labelled ports, zoom, pan, and auto-layout. A keyboard-operable structure view sits alongside, so nothing depends on dragging.

Glossary and assumptions

Give every input a human meaning, and state constraints explicitly. Tangibool never assumes that “premium member” implies “member” unless you add that assumption yourself.

Reusable subcircuits

Save a selection as a named, versioned subcircuit with typed ports. Each instance is pinned to a version and never upgrades silently; expand it to see the values inside. Keep libraries for yourself or your team.

Edits you can’t lose

Undo and redo everywhere. An invalid draft never overwrites your last valid model: it stays visible, clearly labelled as the previous valid revision, until you fix the errors in your current text.

Beyond TRUE and FALSE

Rules depend on ages, amounts, plans, countries, ratings, counts, and scores. Define each one outside the formula, and Tangibool compiles it to TRUE/FALSE inputs with the facts between them derived exactly and labelled as derived, so every check stays two-valued and every result stays exact.

Numbers and thresholds

“Age is at least 18” becomes the threshold input age_at_least_18, defined as age ≥ 18 on a whole-number or decimal quantity. Type a comparison into a formula and the editor offers the definition. Give a number in a scenario and every threshold on that quantity is decided by exact comparison, with the ordering between thresholds derived for you: anyone aged 25 or more is aged 21 or more.

Categories, lists, and sets

Define plan with Free, Basic, Pro, and Team, or country with ISO codes, and name lists of values: EEA, Paid plans, or a union, intersection, or difference of other lists. A category input holds one value, a set-valued input holds any subset, and formulas test membership with plan IN Paid or activities HAS NONE Excluded. Facts such as “every collaborative plan is paid” are derived from the lists, never guessed. Two or three lists of a category are drawn as a Venn diagram with the values in each region, and lists that name a parent list appear as a tree.

Ordered scales

Credit ratings, risk classes, customer tiers: a scale lists its levels from lowest to highest, plus outside values such as Not rated that satisfy no comparison. rating ≥ BBB- gets neighbouring-level boundaries and boundary tests, a comparison input relates two quantities on one scale, and a mapping between two scales must preserve order and is a versioned resource that you confirm. The mapping is drawn as arrows between the two scales, with the levels that share a target and the levels left untranslated listed under it.

Counting constraints

“At least two of three criteria” is a count, not a chain of XOR. AT_LEAST(k; …), AT_MOST(k; …), and EXACTLY(k; …) take two or more conditions and appear as one gate in the diagram, with the literal reading “at least 2 of …” and boundary cases at k−1, k, and k+1 conditions.

Points tables

A score adds up the points of the rows whose condition holds, and score thresholds such as score_at_least_5 are inputs that your formulas use by name. The evaluation trace lists each row’s contribution and the total, the score range is shown, and a cutoff outside that range is flagged as a constant.

Outcome sets and decision tables

A decision can have more than two outcomes: Approve, Refer, Decline. Define them as one condition per outcome, as a rule list where the first match wins, or as a decision table with the hit policy Unique, Any, First, or Priority. Formulas read an outcome like a category: preapproval IN {Approve, Refer}.

Check

Exact answers, with the evidence attached

Ask a precise question and get a precise answer: holds or doesn’t, with the assignment that proves it. Every result states the property checked, the assumptions, the method, and the revision it applies to.

Affirming the consequent: the street is wet, so it must be raining? Tangibool reports the argument invalid and shows why.

Exact questions

Can this be true? Is it always true? Can it ever be false? Are these two equivalent? Does the conclusion follow? Is this rule at least as strict as that one? Does every case get exactly one outcome? Each is a precise satisfiability query, not a guess.

Witnesses you can replay

Every counterexample and witness is re-run in the evaluator before it’s shown. Load it into the simulation or save it as a regression test in one click.

Assumptions checked first

Assumptions are tested for consistency before anything else. An impossible set of assumptions can never produce an “all tests pass” or “equivalent” badge.

Arguments, properly

State premises and a conclusion. Get “valid”, or the assignment where every premise holds and the conclusion fails. Premises that contradict each other get a prominent warning, not a hollow success.

Which inputs matter

See whether each input can change a result, proved with two assignments that differ only in that input. Find out whether a premise already follows from the others.

Conflicts traced to source

When assumptions or premises can’t all hold, Tangibool returns a checked conflicting subset mapped back to your original clauses, and says plainly what wasn’t tested.

Why a result

For an output or an outcome, see the necessary conditions that every qualifying case shares, the ways to qualify, each a set of facts that guarantees the result with nothing removable, fewest facts first, an irreducible reason for one case, and the smallest changes to the inputs you allow to change that give a different result. Every fact replays, and a list is called complete only when the engine has shown it is.

Strictness and monotonicity

Compare two rules, two revisions, or two branches: at least as strict, equivalent, looser, or incomparable, with a replayed case for each direction that fails. Draw a strictness map for up to twelve rules, declare rule layers such as regulation, prospectus, mandate, and internal limit and check each against the one above it, and state that raising an input never turns a result from TRUE to FALSE. Every answer is exact, and each runs as a property test.

Exactly one outcome

An outcome set is checked for completeness and exclusivity: every admissible case gets an outcome, and no case gets two. Gaps, overlaps, and rows that can never apply are reported with replayed cases and never repaired behind your back, and a table with a gap or an overlap exports only as a labelled draft.

The strictness map, drawn

The map of up to twelve rules is a drawing as well as a list. Looser rules sit above stricter ones, a line joins neighbours, and rules with no path between them are incomparable. Select a line to open the replayed case that the looser rule allows and the stricter one does not.

Venn diagrams of rules

Pick two or three rules and see which combinations can happen. The engine decides each region exactly: it holds a replayed case, or it is hatched and labelled empty. Under the drawing, in words: equivalent, at least as strict, never both TRUE, or every case has one of them.

Drawings that stay honest

A drawing is a view of a result, never a result of its own. A pair or a region the engine could not decide is labelled Not determined, never drawn as unrelated or empty. Every drawing has a text form beside it for keyboards and screen readers, and no status rests on colour alone.

Exhaustive where it can be. Honest where it can’t.

Small models are checked over every assignment in your browser and cross-checked by a SAT solver. Larger ones use a bounded solver query on the server, with a two-second default budget, and only after you agree to send the model. Analyses that need many queries, such as the ways to qualify or a strictness map, share a ten-second budget and are labelled partial when it runs out.

  • Out of budget? The answer is “Not determined”, never “passed”
  • Derived assumptions apply everywhere, so no witness, way, reason, or change describes a case that cannot exist
  • Sampled scenarios are labelled exploration, never a guarantee
  • Change the logic or assumptions and earlier results are marked stale
The Analysis tab answering Which inputs matter? for allow_entry: member can change the result, exhaustively checked and solver cross-checked, shown with the pair member=F invited=F banned=F giving FALSE and member=T invited=F banned=F giving TRUE.

Explain

A plain-English reading you can trust

Every formula gets a literal reading generated by the engine, not by AI, so it is exactly as precise as the logic. Toggle a scenario and an evaluation trace explains why each gate is TRUE or FALSE.

  • Four content languages: English, French, German, and Spanish
  • Three levels: beginner, intermediate, and advanced (the presentation changes, the meaning never does)
  • Linked highlighting: select a formula fragment, gate, clause, or truth-table column and it lights up everywhere
  • Every construct read literally: thresholds as conditions on numbers or levels, membership as the values it admits, counts as “at least 2 of …”, points with each row’s contribution and the total, and the reason a case got its outcome
  • Optional AI paraphrase, always labelled as a paraphrase, with the exact reading beside it
Reading · EnglishIntermediate

allow_entry is true exactly when both of the following hold:

  1. at least one of member (“the person is a member”) or invited (“the person has an invitation”) is true (both may be true)
  2. banned (“the person is banned”) is false

In every other case, allow_entry is false.

Why · evaluation trace

  • TRUE (member OR invited) = TRUE because member is TRUE
  • TRUE NOT banned = TRUE because banned is FALSE
  • TRUE (member OR invited) AND NOT banned = TRUE because every operand is TRUE

Test

Treat rules like code

Simulate scenarios, see the complete truth table, save tests with their provenance, and find out how good those tests really are. Then run the same suite in continuous integration.

The truth table of allow_entry with eight rows, columns for member, invited, banned, the intermediate columns NOT banned and (member OR invited), the output, and the scope of each row; the current scenario row is highlighted.
Complete truth tables with intermediate columns: automatic up to 8 inputs (256 rows), and up to 12 inputs (4,096 rows) on request.

Simulation without guessing

Toggle inputs and watch values flow through the diagram. Give a number, a level, a value, or a set and every test on that quantity is decided by exact comparison. An input you haven’t set has no value and is never quietly treated as FALSE.

Tests with provenance

Save scenario and property tests with notes. A scenario can expect an outcome label, and a different label fails naming the deciding row or condition. Each expectation records where it came from: Independent when a person confirmed it, Exploratory when it was copied from the formula itself.

Regressions, flagged

Rerun after every edit. Results from older revisions are marked stale, newly failing tests are called out, and the failing path is traced on the diagram.

Coverage with real denominators

Input-value, gate-output, and decision-outcome coverage, then category classes, counting boundaries, outcome labels, and decision-table rows, plus input influence shown by paired scenarios. Every metric publishes its denominator, and unreachable classes and rows are excluded and listed. Where a category has two or three membership tests, its value classes are marked covered or not covered on a Venn diagram.

Mutation testing

Up to 500 seeded single-edit mutants: AND↔OR swaps, negations, substitutions, and removed clauses, and for the richer inputs a moved threshold or cutoff, a changed count, a list member moved, a changed weight, or a removed or reordered row. Equivalent mutants are found by exact comparison, and the score never hides what it excluded.

A headless runner for CI

The tangibool command runs the same engine on an exported package, or on a cloud model that it reads through the API with a token, and writes JSON and JUnit reports. Exit code 0 only when at least one applicable test ran and all of them passed.

Boundary and class tests

Tangibool proposes boundary tests either side of a threshold or a score cutoff, and class tests, one scenario per class of category values that the logic treats alike. Coverage reports whether each count was seen with k−1, k, and k+1 conditions. Every proposal is exploratory until you confirm it.

Strictness as a test

“At least as strict as” and “raising this input never turns the result from TRUE to FALSE” are saved as property tests with the statuses pass, fail, vacuous, and not determined. They run in suites, in the browser, and in the headless runner.

Values travel with the test

A saved test keeps the number, level, value, or set you gave, so editing a list or a threshold changes what the test checks, marks earlier results stale, and shows up in the behaviour comparison with a witness that gives a value.

Find out what your tests would miss

Mutation testing makes small deliberate mistakes in your rule and checks whether your saved tests notice. A surviving mutant comes with the scenario that tells it apart, ready to become your next test.

The score is killed ÷ (killed + surviving). Equivalent, invalid, out-of-scope, and undetermined mutants are shown separately, and an empty denominator is never reported as 100%.

tangibool test model.json --revision main \
  --junit reports/tangibool.xml --json reports/tangibool.json
Mutation testing results: 25% score, killed 7 divided by killed plus surviving 28, with counts for killed, surviving, equivalent, invalid, out-of-scope, and not-determined mutants, and example mutants: one killed by the counterexample test, and one surviving with the scenario that distinguishes it.

Algebra

Transform a rule, with proof it still does the same thing

Every transformation shows its scope, size, and an exact equivalence result before you accept it. Your original stays editable until you choose the replacement.

  • Simplify with named laws: identity, domination, idempotence, complement, absorption, double negation, and De Morgan. Called “simplified” for your chosen objective, never “minimal”.
  • CNF and DNF over your original variables, within declared bounds, never an auxiliary-variable encoding passed off as equivalent.
  • Karnaugh maps for up to four inputs, in Gray-code order with wraparound groups and a derived expression that is checked exactly.
  • NAND-only and NOR-only implementations that keep your input names and carry equivalence evidence.
  • Counting constraints expand into plain gates with the named law count-expansion, within the same bounds. Score thresholds stay references and expand only on request.
The Algebra tab showing the Karnaugh map of allow_entry as a complete function, with the variable order member, invited, banned, Gray-code columns 00, 01, 11, 10, and the cells m2, m4, and m6 set to 1.
A NAND-only transformation of allow_entry: complete and exactly equivalent, 11 NAND gates at depth 5 within the 20,000-node bound, with the resulting NAND expression.
A NAND-only implementation: 11 gates, exactly equivalent on every assignment.

History

Version control built for logic

Not a Git wrapper: native history that understands rules. A commit captures the logic, wording, glossary, diagram, assumptions, tests, and shared notes together, so an old formula can never be paired with a newer diagram.

The History page for Entry rule with 2 branches and 2 commits: the revision graph lists Explore: invitations bypass the ban on branch invitation-exception and Start from example: Entry rule on main; the selected commit shows actions to view, export, compare, branch, restore, or revert, and its change summary with a formula diff.

Atomic commits and checkpoints

Explicit commits with messages, plus recoverable autosave checkpoints kept for 30 days, even for invalid drafts. Promote any checkpoint to a named commit.

Branches and tags

Branch to explore an exception without touching the original. Tags name a fixed commit; an approved-baseline tag also requires current checks and a confirmed interpretation.

Four kinds of difference

Text, structure, visual layout, and behaviour are compared separately. A formatting change, an equivalent refactor, a scope change, and a behaviour change each get their own label.

Three-way merges

Compatible edits combine. Conflicting ones, such as changes to the same operator, connection, meaning, test expectation, or note, are shown for review. Relevant checks rerun before you commit the merge.

Reviews and protected branches

Open merge requests, require approval from an independent reviewer, and protect important branches with mandatory current checks. Rules are enforced on the server.

Restore without rewriting

Restore a whole model or selected artifacts, with dependencies resolved first. A restore is always a new commit, and later comments and notes are never rolled back.

History, branches, and comparisons work offline in local models. No Git account or external repository is needed, and exported files are deterministic, so you can keep them in your own repository too.

Collaborate

Review rules together, without losing context

Comment on the exact thing you mean: a formula fragment, a gate, a clause, a test, or a revision. If the logic changes later, the comment says so instead of silently attaching itself to something new.

  • Threads labelled Comment, Question, Feedback, or Decision, and resolved with a link to the test or commit that settled them
  • Private notes by default, shared notes when you choose, both in Markdown with full history
  • Mentions and in-app activity for replies and threads you follow
  • Resolving a discussion never changes a formula, a test, or a verdict
The Comments and Notes panel open beside the workspace: a question thread titled Should a ban also override an invitation? anchored to the input banned at a specific commit, with the banned node highlighted on the diagram and actions to reply, resolve, create a test, or turn the comment into a private note.

Cloud sync when you want it

Sign in and copy a local model to your personal or team cloud. Edit offline and sync later; concurrent edits are kept side by side for an explicit merge, never overwritten.

Five roles, enforced on the server

Owner, admin, editor, commenter, and viewer. Commenters can discuss but not edit logic; viewers can read. Private notes stay private, even from owners and admins.

Snapshot links

Share a fixed, read-only snapshot that never follows later edits. Links are private until you grant access, and they can be revoked or set to expire.

Review rubrics

Configure the optional AI review with your own questions and thresholds, covering omitted conditions, exception scope, or a reversed “only if”. Versioned, and never a substitute for confirmation.

Organisation terminology

Keep shared terms, synonyms, and confirmed domain assumptions in one versioned glossary. Changing a term withdraws the approvals that depended on it.

Team libraries

Publish subcircuits, categories with their value lists, scales, and scale mappings to a team library. Models stay pinned to the version they use until someone reviews and approves the upgrade.

Export

Take your rules anywhere

Export a single artifact, a selection, or everything from one pinned revision, so a package can never mix an old formula with a newer diagram. Exports run in your browser, never call AI, and never change the model.

  • Export All builds one ZIP with a manifest, checksums, and per-file status
  • Full-history packages carry branches, tags, and pinned dependencies
  • The browser, the headless runner, and the API produce the same files
The Export dialog listing each artifact with its available formats: model report in .md, .txt, .json, .tex, .png, .jpg, .jpeg, and .svg; formal model in .md, .txt, .py, .json, .sql, .tex, and .smt2; truth table, test suite, test results, and diagram images.
Export formats and what each one contains
FormatWhat you get
.pyA readable Python 3 evaluator and a unittest suite, with strict Boolean input checks: strings, numbers, and None are rejected, never coerced. Thresholds, category values, scale levels, counts, and points are computed from the values you pass, undeclared values are rejected, and an outcome set returns its label.
.sqlA PostgreSQL Boolean expression with a read-only SELECT and a VALUES test harness. Missing or NULL inputs are reported as invalid, never silently treated as FALSE. Counts and scores are sums of CASE expressions, and an outcome set is a CASE in table order.
.smt2SMT-LIB Boolean definitions and scoped satisfiability queries, including completeness, exclusivity, strictness, and monotonicity, with each sat / unsat outcome explained.
.texLaTeX fragments or standalone reports: formulas, truth tables, decision tables, algebra steps, and TikZ diagrams and Karnaugh maps, count and score gates included.
.md · .txtReadable reports: source rules, explanations, glossary, tests and results, transformations, comments, and notes. Also the text form of a strictness map, a Venn diagram, or a mapping diagram.
.jsonThe lossless native format: a model snapshot or a full-history package you can import again. Also the result behind a strictness map, a Venn diagram, or a mapping diagram.
.png · .jpg · .jpeg · .svgGate diagrams, truth-table pages, Karnaugh maps, strictness maps, Venn diagrams, mapping diagrams, and report cards, at the size, scale, and theme you choose, with real JPEG data under either extension.
.csv · .xmlTruth tables and scenario suites as CSV, with spreadsheet-formula injection neutralised; JUnit-compatible XML test reports.

Generated Python, SQL, and SMT-LIB are produced from tested templates, never by AI, and are cross-checked against the engine on thousands of generated models before every release. Exporting code does not run it.

API

Build on Tangibool from your code and your AI assistant

A documented, versioned API and an MCP server answer with the same engine as the app: the same verdicts, the same replayed cases, the same limits. A program acts for a person, within the scopes that person gave it and the role that person holds. Both are on every plan.

Personal access tokens

Create a token in your account settings for a script or a CI job. Give it only the scopes it needs, limit it to named teams or models, and revoke it at any time. Every token expires, after 90 days by default and a year at most, and Tangibool stores only its hash.

A public API, in any language

Version 1 is a documented contract with an OpenAPI specification. Create a model from rule text kept in your repository, run exact checks and saved tests, and collect results and exports. A verdict is holds, violated, or unknown, never an HTTP error.

Changes with a dry run

Send edits as a change set: add an input, change a formula, add a test. A dry run returns the diagnostics, the resulting outline, and the behaviour comparison, and stores nothing. A commit moves the branch only if nobody else has moved it in the meantime.

Analyses without a stored model

Send logic with the request to parse it, evaluate a case, check a property, compare two rules, page through a truth table, ask why a case got its result, or generate code. The server analyses it in memory and never stores or logs it.

An MCP server for AI assistants

Connect an assistant and approve, in the app, what it may read and do. It can check and compare rules, explain a result, and run saved tests, and the engine computes every result it reports. Its changes arrive as a proposal branch, with tests marked AI-proposed, for you to review and merge.

Webhooks

Have your own systems told when a branch moves, a tag is created, a merge request is opened, merged, or closed, a run or an export finishes, or a discussion starts. Deliveries are signed, retried for up to 24 hours, and carry no model content.

What stays with a person

Whatever its scopes, a program can never confirm what a rule means, confirm a test’s expected result, approve a merge request, or create an approved baseline. Those acts stay with a person in the app, and the server refuses a request that attempts one.

  • History shows which revisions came through a token, a connected app, or an assistant
  • A scope never adds to a role: a viewer’s token cannot write
  • Connected apps are listed in your account, and disconnecting one ends its access at once
  • The API is for authoring, analysis, and testing, not for deciding live cases; exported code is how a rule runs in production

Read the developer docs

Exact check · APICan this be true?
curl -sS -X POST \
  "https://api.tangibool.com/v1/logic/check" \
  -H "Authorization: Bearer $TANGIBOOL_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "logic": { "text": {
      "inputs": [{ "name": "a" }, { "name": "b" }],
      "formulas": [
        { "name": "both", "text": "a AND b" }
      ]
    } },
    "query": { "kind": "satisfiable",
               "formula": "both" }
  }'

The answer carries the verdict, a replayed case, and the digest and engine versions it is bound to.

Learn

Fourteen guided lessons, all open

Every lesson opens real workspace models checked by the same engine, not disconnected illustrations. Exercises give concrete feedback with replayable scenarios, in all four content languages. Progress is saved on your device, and in your account when you sign in.

  1. NOT, AND, OR: the basic operators
  2. XOR: exclusive OR and parity
  3. Grouping and precedence
  4. Truth tables
  5. If, only if, unless
  6. De Morgan’s laws
  7. Simplification laws
  8. Arguments and validity
  9. Counterexamples
  10. Normal forms
  11. Karnaugh maps
  12. Designing tests that find bugs
  13. Categories, scales, and counting
  14. Why this result: reasons and strictness

Start the first lesson

Lesson 1, NOT, AND, OR: the basic operators, a 10-minute beginner lesson. Step 1 explains TRUE, FALSE, and AND with can_borrow := member AND paid, worked examples checked by the engine, a Try it exercise, and an Open in a workspace button.

Honest by design

What Tangibool will never claim

Trust comes from saying exactly what was checked, and what wasn’t. These rules are built into every result, report, and export.

A timeout is not a pass

A check that exceeds its budget says “Not determined”. It never turns into a green tick, and a list of ways to qualify or a strictness map that ran out of budget is labelled partial.

Stale is labelled stale

Change the logic, assumptions, or tests and earlier results say which revision they belong to and can’t be applied.

Vacuous is labelled vacuous

An argument whose premises contradict each other is “valid” only vacuously, and you’re told so prominently.

Solver-checked, not certified

Unsatisfiable results are labelled “solver-checked”. Tangibool doesn’t claim independently verified proof certificates.

Simplified, not minimal

A simplification is better by the objective you chose, such as fewer operators, and a reason for a result is irreducible: no fact can be removed, other reasons may exist. Neither is ever called “the smallest possible”.

Coverage is not confidence

Structural coverage and mutation scores measure your tests. They’re never presented as proof the rule is right.

AI is never the authority

No AI confidence is ever shown as a mathematical guarantee, and no AI output is accepted without you. An assistant connected through the API can propose a change, but it cannot confirm, approve, or merge it.

The model, not the world

Tangibool verifies the model you supply, not the real-world truth, legality, completeness, or safety of a policy.

Operating limits

Clear limits, never silent truncation

These bounds keep every operation fast and exact. They apply to every plan and describe supported sizes, not features you have to unlock. Anything beyond them fails clearly instead of returning a partial result dressed up as a complete one. The API’s request and compute allowances are the one exception: they grow with the plan and are listed on the pricing page.

Tangibool works with two-valued Boolean logic and propositional logic. Numbers, categories, scales, counts, and scores enter through inputs defined outside the formulas, such as age_at_least_18 for age ≥ 18 or plan IN Paid, and compile to TRUE/FALSE inputs whose relationships are derived exactly. It does not do arithmetic beyond a count or a points total, compare two different quantities except on one ordered scale, evaluate text, dates, or units, or quantify over collections such as order lines or portfolio holdings.

Operating limits
WhatLimit
Distinct inputs per model64
Written outputs · premises · assumptions per model64 each
Expression nodes (after expanding subcircuits)500
Nesting depth64
Categories per model · values per category · value lists64 · 2,000 · 500
Value-list hierarchy depth16
Ordered scales per model · levels per scale · outside values64 · 100 · 8
Counting constraint operands2–64
Points tables per model · rows per table · points per row32 · 64 · −1,000 to 1,000
Outcome sets per model · labels per set32 · 32
Decision table500 rows · 64 columns
Membership tests per set-valued input12
Truth table, automatic8 inputs · 256 rows
Truth table, on request12 inputs · 4,096 rows
Karnaugh maps0–4 inputs
CNF / DNF size4,096 clauses · 20,000 literals
Mutation run500 mutants · 30 s
Server solver budget (default)2 s per query
Why-a-result and strictness analyses10 s per operation
Ways to qualify listed200
Smallest changesdistance up to 4 · 50 listed
Strictness map12 rules
Venn diagram2 or 3 lists or rules
Saved tests per model1,000
Natural-language drafting request4,000 characters
Note · comment50,000 · 10,000 characters
Export archive100 MiB · 10,000 files
Images8,192 px per edge · 32 MP
Personal access tokens per user50 active
Token lifetime90 days by default · 1 year at most
Edits in one change set500
Webhooks10 per model · 25 per team

FAQ

Questions about the product

Do I need an account to use Tangibool?

No. Open the app and start working: models, history, tests, notes, lessons, and exports all work signed out, stored in your browser. Sign in when you want cloud sync, teams, sharing, merge requests, AI drafting, or the API. Browser storage is not a cloud backup, so export or copy important models to the cloud.

Does AI decide whether my rule is correct?

Never. AI can draft a formula from your words, suggest clarifications, paraphrase an explanation, or review a draft for likely omissions. Every mathematical result comes from the deterministic engine, and only you can confirm what a rule is meant to say. You can switch AI off entirely and keep every deterministic feature.

What happens when a model is too big to check exhaustively?

For larger models Tangibool runs a bounded SAT query on the server, but only after telling you that the model will be sent. If the query finishes, you get an exact answer; if it runs out of budget, the result is “Not determined”. It never presents a sample of scenarios as a complete check.

Can Tangibool work with numbers, like “age is at least 18”?

Yes, through threshold inputs. A condition like “age is at least 18” becomes the input age_at_least_18, defined as age ≥ 18 on the quantity age. The formula keeps using a TRUE/FALSE input, a scenario or a saved test can give the number itself, which decides every threshold on that quantity by exact comparison, and the ordering between thresholds is derived for you: anyone aged 25 or more is aged 21 or more. The same pattern covers category values (plan IN Paid), levels on an ordered scale (rating ≥ BBB-), counts of conditions, and points totals. Tangibool does no other arithmetic, and it never infers that “premium member” implies “member” unless you add that assumption.

Can a rule have more than two outcomes?

Yes. An outcome set names its outcomes in order, such as Approve, Refer, and Decline, and defines them as one condition per outcome, as a rule list where the first match wins, or as a decision table with the hit policy Unique, Any, First, or Priority. Each outcome compiles to a Boolean output, so every exact check still applies, and the engine checks that each admissible case gets exactly one outcome, reporting gaps, overlaps, and rows that can never apply with a replayed case for each.

Can I check that an internal rule is at least as strict as a regulation?

Yes. Put both rules in one model, or compare two revisions or two branches, and ask whether one is at least as strict as the other: every case the stricter rule allows, the looser rule allows too. The answer is equivalent, at least as strict, looser, or incomparable, with a replayed case for each direction that fails. A strictness map orders up to twelve rules at once, rule layers such as regulation, prospectus, mandate, and internal limit are checked in order, and the same checks run as property tests in continuous integration.

Can I run my Tangibool tests in continuous integration?

Yes. Run the headless tangibool runner on a native JSON package you exported, or on a cloud model that it reads through the API with a token. Either way it uses the same engine as the browser and computes on your machine. It writes JSON and JUnit-compatible reports and exits with 0 only when at least one applicable test ran and all of them passed, 1 when an assertion failed, and 2 for invalid or inconclusive input. You can also start a test run through the API and read its result.

Is there an API?

Yes. A documented, versioned API lets your own programs create and change models, run exact checks and saved tests, and fetch results and exports, with a personal access token that you create in your account settings. It is included on every plan; plans differ in how many requests and how much server compute you get. The developer docs have the guide, the reference, and the OpenAPI specification.

Can an AI assistant work with my rules?

Yes, through the MCP server. You connect the assistant and approve, in the app, what it may read and do. It can check and compare rules, explain why a case got its result, run saved tests, and propose changes, and the engine computes every result it reports. Its proposals arrive on a branch of their own, with tests marked AI-proposed. It can never confirm what a rule means, approve a merge request, or merge: those stay with you.

Does Tangibool replace Git?

For your rules, it doesn’t need it: commits, branches, tags, diffs, merges, and restores are built in and understand logic, diagrams, and tests. Because exports are deterministic, you can still keep the generated files in your own Git repository if you like.

Is Tangibool accessible?

It is designed to the WCAG 2.2 AA standard. Every diagram action has a keyboard alternative, a structured view sits alongside the canvas, controls are labelled for screen readers, and truth values always use an icon and a word, never colour alone. Automated WCAG 2.2 accessibility scans of the main pages and dialogs are part of the test suite, in both light and dark themes.

Which browsers and devices are supported?

Current versions of Chrome, Edge, Firefox, and Safari. Tangibool is desktop-first, and on tablets and phones the same features are arranged in tabs rather than squeezed onto one screen.

See it on your own rule

Paste a condition from your codebase or a sentence from a policy, and find out exactly what it does.