Your AI guesses.
InputLayer reasons.

Store facts. Write rules. InputLayer draws conclusions, keeps them up to date as things change, and can show exactly how it got every conclusion.

Facts
direct_flight("New York", "London")
direct_flight("London", "Paris")
direct_flight("Paris", "Tokyo")
direct_flight("Tokyo", "Sydney")
Rules
can_reach(A, B) <- direct_flight(A, B)
can_reach(A, C) <- direct_flight(A, B), can_reach(B, C)
Conclusions (computed automatically)
can_reach("New York", "Paris")live
can_reach("New York", "Tokyo")live
can_reach("New York", "Sydney")live
can_reach("London", "Sydney")live
Live · Reliable · Traceable · Explainable

How it works

Give your AI conclusions it can trust

InputLayer figures out what's true from the facts and rules you give it. Your AI gets reliable, up-to-date conclusions instead of guessing, and every conclusion can be traced back to the facts behind it.

Thinks, not just stores

Your AI stores facts. InputLayer connects the dots and draws conclusions automatically.

Search + logic together

Find things by similarity, then filter by what's actually true. One query, both at once.

Shows its work

Every conclusion traces back to the facts and rules that produced it. Ask "why?" on any result.

Always up to date

When a fact changes, every affected conclusion updates in milliseconds. No waiting, no rebuilding.

Comparison

What you get that other tools don't do

Databases store data. InputLayer thinks about it, combining search, logic, and live updates in one place.

CapabilityVector DBsGraph DBsSQLInputLayer
Find by similaritypluginplugin
Follow connectionspartial
Apply rulespartialpartial
Chain logic together
Live updatespartial
Undo when facts changerecomputerecompute
Explain every conclusionpartialpartial

Search + logic

Where can I fly that feels like a beach vacation?

You're in New York and want beach destinations, but only ones you can actually get to. First, InputLayer follows the flight network to figure out which cities are reachable (even with connecting flights). Then it ranks those cities by how well they match "beach vacation."

One query does both

Rules figure out where you can go. Search ranks by what you want. InputLayer does both in a single query. No stitching things together, no extra steps.

Open in Studio
embedding dimension 1embedding dimension 2ranked by similarity to "beach vacation"REACHABLEUNREACHABLESydney0.08Tokyo0.52London0.61Paris0.65Rio0.12Bali0.15query"beach vacation"

Smart undo

Cancel a route. Does the destination stay reachable?

Sydney is reachable from New York two ways, through Tokyo and through Dubai. Cancel the Dubai route, and most systems would just wipe the conclusion. But the Tokyo route still works.

InputLayer tracks both paths. It only removes a conclusion when every way to reach it is gone. Sydney stays reachable until both routes are cancelled. No wrong removals, no stale conclusions.

Open in Studio
derivesderivesSydneyvia Tokyovia DubaiREACHABLEDubai cancelled - still reachable via Tokyoboth cancelled - correctly unreachable

Instant updates

Add a route. Only the affected conclusions update.

Your flight network has 2,000 airports and hundreds of thousands of possible connections. Add one new route, say London to Dubai, and most systems recalculate everything from scratch. InputLayer only updates the conclusions that actually changed.

6.83ms

incremental update

11.3s

full recompute

1,652x

faster

Open in Studio
Full recompute11.3s
recomputes all 400,000 reachable pairs
Incremental update6.83 ms
1,652x faster

Explainability

Ask "why?" and get the full reasoning chain

How does New York connect to Sydney? Ask .why and see every step: NY to London, London to Paris, Paris to Tokyo, Tokyo to Sydney. Or ask .why_notto see why São Paulo can't be reached. Every conclusion comes with the receipts.

100%

of results fully explainable

Open in Studio
can_reach("new_york", "sydney")conclusion
can_reach(A,C) <- direct_flight(A,B,_), can_reach(B,C)rule
direct_flight("new_york", "london", 7.0)fact
can_reach("london", "sydney")derived
can_reach(A,C) <- direct_flight(A,B,_), can_reach(B,C)rule
direct_flight("london", "paris", 1.5)fact
can_reach("paris", "sydney")derived
can_reach(A,C) <- direct_flight(A,B,_), can_reach(B,C)rule
direct_flight("paris", "tokyo", 12.0)fact
direct_flight("tokyo", "sydney", 9.5)fact

Open source. Run it yourself.

No account, no API key, no vendor lock-in. From first query to production in four steps.

1

Try it in 30 seconds

One Docker command, instant local instance.

Launch demo
2

Learn the syntax

How to write facts, rules, and queries. The full reference.

Read the docs
3

Deploy with your stack

Self-hosted Docker or Kubernetes. Your infra, your data.

Deployment guide
4

Go to production

Apache 2.0 + Commons Clause. Commercial license when you need it.

View license
docker run -p 8080:8080 ghcr.io/inputlayer/inputlayer