A decision intelligence system that ends in an action queue,
Telumin is an action engine: it watches the event streams you declare, argues about what matters, and delivers a calibrated queue of evidenced actions — each with the exposure, the proof, and a decision window. Deployed in your cloud or ours.
Book a demo30 minutes, with the engineer who deploys itFeatures
Typed triggers
Declare what matters; the engine watches it. Plain-text rules your team owns — an event code, a threshold, a keyword — checked every five minutes against six sources.
Calibrated queue
Every action arrives with its evidence. Direction, magnitude in your units, a decision window — and the source, timestamp and excerpt behind it.
Most monitoring stops at the alert. Something crosses a threshold, a message appears, and the hard part — deciding what it means for you, and whether it is worth acting on — is handed straight back to a human who is already busy.
So teams do the rational thing: they turn the alerts down. The dashboard stays green because nobody is looking at it. The channel fills up with noise nobody reads. And the one event that actually mattered arrives in exactly the same font as the two hundred that did not.
We think the missing piece is not another feed. It is the work that happens between the event and the decision: checking a candidate against rules you declared, arguing about whether it is material, computing what it costs you specifically, and attaching the evidence so the claim can be checked.
That work is mechanical enough to automate and consequential enough to deserve rigor. So the engine runs an Advocate that argues a finding matters, a Skeptic that attacks it, and an Adjudicator that rules. Most candidates die there. That is the point: silence is a first-class output, and an auditable one.
What survives is not an alert. It is a proposed action carrying a direction, a magnitude in your units, a decision window, and its receipts. Your team accepts or rejects it, and that call is logged with its reason — so the system accumulates institutional memory instead of notification fatigue.
One rule is absolute: the engine proposes and never executes. There is no order-routing code, no credentials in a vault, no autonomous action. Not as a policy that could be relaxed later — as an architecture that has no such path in it.
We proved the pattern where the consequences are immediate and the noise is relentless: investment portfolios. That became Telumin’s first product, and it is a solution built on the engine — not the engine itself. The same loop now watches our own production, and it is the same loop we deploy for a supply-chain desk, a compliance team, or an infrastructure group.
If your events can be landed and your definition of “worth a look” can be written down as rules, the engine applies. If it cannot, we will tell you that in the first call rather than the third invoice.
Declare what deserves attention
Your team writes the rules in plain text — typed triggers like an event code, a numeric threshold, or a keyword. Reviewable, versionable, and yours to keep.
- Event codes, thresholds, keywords
- Six sources landed continuously
- Plain text you own and version
Argue before it reaches anyone
Every candidate faces a three-role debate — Advocate, Skeptic, Adjudicator. Most die there, and the silence is logged as carefully as the signal.
- Advocate, Skeptic, Adjudicator
- Most candidates never ship
- Silence is logged too
Deliver an action, not a notification
What survives ships as a proposed action: direction, magnitude in your units, a decision window, and the evidence behind it.
- Magnitude in your units
- A decision window, not a deadline
- Source, timestamp and excerpt
The engine watches our own production the same way it watches a customer's. It flagged an expiring TLS certificate three days before anything broke — that is the whole product in one sentence: it noticed, it priced the consequence, and it waited for a human to decide.
Customer zero
Telumin’s own production
Every action carries its receipts
Direction, magnitude, impact horizon, decision window — plus the source, the timestamp and the excerpt. If it cannot show its work, it does not reach you.
Data residency
Runs where your data already lives. Shared EU tenancy, a dedicated node in your region, or containerized inside your own VPC.
Calibration, not volume
Exposure computed by code, not a model. The engine is tuned to drop most of what it reads — the ratio that survives is the product knob.
Decision windows
Decide before open, or you have three weeks.
Evidence attached
Source, timestamp and excerpt, frozen at collection.
Decision log
Accepts and rejects recorded with your reason.
Falsifiable by design
Every signal states what would prove it wrong.
The agent your team already uses
One MCP connector — claude.ai, Claude Code, or an agent you built. Your analyst asks the queue questions in the context window; we never see your systems, and there are no API keys to rotate.
Read the connector docsOne engine. The vertical is just the rules you give it.
We built the engine to solve one problem properly, then found the shape was general. Two domains run in production today; the rest is a week-one pilot on your streams.
Portfolio early-warning
Live — our first product
Positions and the written reasons behind them become watch rules. Threats arrive priced in dollars on the actual holding, with the filing or price event attached.
See the productOperations & infrastructure
Live — customer zero
The same loop watches Telumin’s own certificates, infrastructure and signup funnel. It fired on our TLS certificate three days before expiry.
Supply chain
Pattern applies
Supplier filings, shipping events, input-cost moves, single-source risk — the thresholds your desk already watches by hand.
Regulatory & compliance
Pattern applies
Rule changes, filing deadlines, licence and certificate expiries — the events with hard dates and real penalties.
Deployed inside your perimeter
The engine deploys where your data already lives. On the private tiers nothing egresses beyond the sources you allow, and inference runs on local models inside your perimeter.
Nothing leaves that you did not send
Derived events in, action queue out. We hold no credentials, keep no copy of your data, and there is no execution path to compromise.
- No credentials held, ever
- Zero autonomous actions
- Export and delete in one click
Your cloud or ours
Shared EU tenancy, a dedicated node in your region, or containerized in your own VPC.
Local-model inference
On the private tiers the models run where the data lives — the model comes to the data.
No credentials held
No broker, custodian, or system credentials. There is no vault to breach.
No execution path
A compromised session could at most add noise to a queue — visible and reversible.
From first call to a running tenant
No self-serve checkout for the engine. A conversation, a contract, then a deployment shaped to your compliance reality.
Answered within one business day · travis@telumin.com
Book a demo
Thirty minutes with the engineer who builds it. You show us the streams you watch by hand today; we show you the queue running on Telumin’s own production.
Scope and sign
We write the first watch rules together and agree the terms in writing — pricing, DPA, security questionnaire — before anything runs. No sales team to negotiate with.
Deploy
Your tenant is provisioned: shared EU tenancy, a dedicated node in your region, or containerized inside your own VPC. Days, not months.
Onboard and calibrate
We land your streams, tune the materiality bar against your noise for a week, and connect your agent. You keep the thesis packs — they are plain text you own.
