semisift

Cognitive atoms for AI agents.

12 hosted primitives you compose into any intelligent system. diff. interpret. match. score. explain. store. recall. predict. sense. subscribe. emit. pulse. Every atom speaks the same Signal schema.

// 1. What changed?
POST /v1/atom/diff
{ "state_a": oldPage, "state_b": newPage }
 
// 2. What does it mean?
POST /v1/atom/interpret
{ "data": diffResult.payload.summary }
 
// 3. Does it matter?
POST /v1/atom/match
{ "signal": interpretation, "criteria": "price drops over 10%" }
 
→ Signal { "relevant": true, "confidence": 0.95 }

What Is SemiSift

Atoms in. Agents out.

SemiSift gives AI agents their body. LLMs can think — but they can't sense changes, remember patterns, judge relevance, or explain decisions without infrastructure. SemiSift is that infrastructure: 12 cognitive atoms, each doing one thing perfectly, all speaking the same Signal schema. Compose them into any pipeline. We host the atoms, the state, and the execution. You write the logic.

You Compose

diff() → interpret() → match() → explain()

↓

semisift

Auth→Validate→Execute atoms→Signal out→Usage logged

↓

You Receive

Signal

relevant, confidence, summary, reasoning, entities, metrics

The 12 Atoms

Twelve atoms. Infinite compositions.

Each atom does one irreducible cognitive operation. Compose them into any pipeline.

diff()

Pure

What changed?

Pure text comparison. No LLM, no cost. Finds exactly what’s different between any two states. The foundation of every monitoring pipeline.

POST /v1/atom/diff { state_a, state_b }

interpret()

LLM

What does it mean?

LLM extracts structured meaning from raw data. Entities, summaries, categories. Turns noise into understanding.

POST /v1/atom/interpret { data, categories? }

match()

Rules + LLM

Does it matter?

Two layers: deterministic rules run free (Dumb Sift), then LLM evaluates semantic intent (Smart Sift). Rules gate the expensive call — 95% of irrelevant signals filtered at zero cost.

POST /v1/atom/match { signal, criteria, rules? }

score()

Pure

How confident?

Normalize and calibrate confidence. Pure math, no LLM. The slot for Bayesian adjustment as your pipeline learns.

POST /v1/atom/score { signal }

explain()

LLM

Why?

Generate human-readable reasoning for any decision. Audit trails, user-facing explanations, compliance logs. Trust requires transparency.

POST /v1/atom/explain { decision, inputs? }

store()

Pure

Remember this.

Persist any signal to managed storage. No database to set up. Keyed by stream, indexed by time. Memory for your agents.

POST /v1/atom/store { signal, stream_id }

recall()

Pure

What happened before?

Query stored signals by stream, time window, and keywords. Feed history into match or predict. Pattern detection without infrastructure.

POST /v1/atom/recall { stream_id, window, query? }

predict()

LLM

What happens if...?

LLM evaluates scenarios against your situation and context. Feed it recall data for pattern-based predictions. Forward-looking analysis for autonomous decision-making.

POST /v1/atom/predict { situation, scenarios }

sense()

Pure

What’s out there?

Fetch any URL and extract text content. The eyes of your agent. HTTP mode runs serverless. Pipe output into diff to detect what changed.

POST /v1/atom/sense { url, method? }

subscribe()

Pure

Wake me when this happens.

Register criteria and a callback URL. When emit() sends a matching signal, your webhook fires. Event-driven agents without polling.

POST /v1/atom/subscribe { criteria, callback_url }

emit()

Hybrid

Tell the network.

Broadcast a signal to all matching subscribers. Semantic matching — your criteria is natural language, not rigid filters. The publish side of the signal bus.

POST /v1/atom/emit { signal }

pulse()

Pure

Keep the heartbeat.

Schedule any atom to fire on an interval. Every 5 minutes, sense a URL. Every hour, recall and digest. The proactive trigger that makes agents autonomous.

POST /v1/atom/pulse { interval_seconds, action }

Every atom returns a Signal — the same schema. The output of any atom is valid input to any other atom. That's composability.

The Signal Schema

One schema to connect them all.

Every atom produces a Signal. Every atom consumes Signals. No adapters, no format conversion, no glue code. The Signal schema is the USB port for the cognitive nervous system.

json

{
  "signal_id": "sig_a1b2c3...",
  "source": { "primitive": "match" },
  "primitive_history": ["diff", "interpret", "match"],
  "payload": {
    "summary": "iPhone 15 Pro price dropped $100",
    "entities": [
      { "name": "iPhone 15 Pro", "type": "product", "change": "modified" }
    ]
  },
  "evaluation": {
    "relevant": true,
    "confidence": 0.95,
    "reasoning": "Price drop exceeds 10% threshold"
  },
  "metrics": {
    "total_latency_ms": 2100,
    "total_tokens_used": 312
  }
}

primitive_history shows every atom this signal passed through. metrics shows the cost. evaluation shows the decision. One format. Zero integration work.

Before & After

Six months of engineering. Or twelve API calls.

Without SemiSift

python

# You build and maintain:
postgres = setup_database()          # schema, migrations, backups
redis = setup_cache()                # session state, dedup
scheduler = setup_cron()             # timing, retries, failure handling
scraper = setup_crawl4ai()           # browser automation, proxies
differ = build_diff_engine()         # text comparison, change detection
llm = setup_openrouter()             # prompts, parsing, rate limits, fallbacks
memory = build_signal_storage()      # indexing, querying, TTL cleanup
webhook = build_delivery()           # retries, signatures, logging
monitor = setup_observability()      # Sentry, Datadog, alerts

# 3-6 months. $200K+. And you haven't built your actual product yet.

With SemiSift

javascript

const page    = await fetch('/v1/atom/sense',     { body: { url } })
const diff    = await fetch('/v1/atom/diff',      { body: { state_a: old, state_b: page } })
const meaning = await fetch('/v1/atom/interpret',  { body: { data: diff.payload } })
const match   = await fetch('/v1/atom/match',      { body: { signal: meaning, criteria } })
const why     = await fetch('/v1/atom/explain',    { body: { decision: match } })
await fetch('/v1/atom/store', { body: { signal: match, stream_id: 'pipeline' } })
await fetch('/v1/atom/emit',  { body: { signal: match } })

// Or compose: POST /v1/composite/sift — one call for the whole pipeline
// Plus: subscribe(), predict(), recall(), pulse() — 12 atoms total

The atoms are hosted. The state is managed. The execution is serverless. You write the logic, we run the infrastructure.

What Developers Build

One platform. Infinite products.

Developers compose atoms into products. Here's what's possible with 7 primitives.

Competitive Intelligence

watch + sift + digest

Monitor 50 competitor pages. Sift filters noise. Store builds history. One daily briefing instead of 50 notifications.

“alert on pricing changes and new product launches”

50 pages → 1 briefing

Autonomous Repricing

watch + sift + recall + match + react

Detect competitor price drops. Recall checks if it's a pattern. Match validates against margin rules (Dumb Sift — free). Adjust your Shopify prices automatically.

“sustained price drops in my category over 2 weeks”

Detection → validation → action

Smart Alert Routing

sift + match + match + emit

Every signal gets evaluated against multiple team criteria. Infrastructure issues → DevOps. Customer-facing → Support. Security → SOC. Natural language routing.

“security vulnerabilities or unauthorized access attempts”

1 signal → right team

Agent Memory

interpret + store + recall

Your AI agent processes conversations. Store extracts structured signals. Recall feeds context into the next interaction. Memory without a database.

“recall customer's past complaints and resolution history”

Stateless agent → context-aware

Compliance Monitoring

watch + sift + explain + store

Regulatory pages change. Sift evaluates relevance. Explain generates audit-ready reasoning. Store creates the compliance log. Zero manual review for 90% of changes.

“changes to lending regulations affecting consumer credit”

Manual review → automated audit

Trend Detection

sift + store + recall + interpret

Store every sift result. Recall pulls 30 days of history. Interpret synthesizes: 'Competitor has dropped prices 4 times this month — sustained strategy shift.' Pattern detection from signal accumulation.

“analyze pricing trends across stored signals”

Isolated events → patterns

Integrate

Five minutes to first atom.

bash

curl -X POST https://api.semisift.com/v1/atom/interpret \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "data": "Q3 revenue was $4.2M, up 15% YoY. Headcount reduced by 12%.",
    "categories": ["financial", "operational", "strategic"]
  }'

Signal schema

Each atom returns a Signal — pipe outputs into inputs

rules[]

Run free before the LLM (Dumb Sift)

Composites

Or use a composite: POST /v1/composite/sift runs diff → interpret → match → score → explain. Build your own in the sandbox.

The Body for AI Minds

LLMs are the mind. SemiSift is the body.

AI models can think, reason, and converse. But a mind without a body is a brain in a jar. SemiSift gives agents senses (sense), comprehension (interpret), judgment (match), memory (store/recall), voice (explain), foresight (predict), reflexes (subscribe/emit), and rhythm (pulse). Nobody has built the body yet. That's the gap.

Agent A

“monitors & stores”

sense

diff

interpret

match

emit

store

sense → diff → interpret → match → emit → store

Agent B

“recalls & acts”

Signal

Shared Signal Store

Agent A stores. Agent B recalls.

Composable

12 atoms compose into any pipeline. sift() is one composition. Build yours.

Signal-native

Every atom speaks the Signal schema. Output of one is input to another. Zero adapters.

Dumb Sift / Smart Sift

Deterministic rules run free before the LLM. 95% of noise filtered at zero cost. Only the signal that matters hits the expensive model.

Not better notifications. The cognitive infrastructure for autonomous systems.

FAQ

Validated in production.

The atom engine powers NotifyBee — monitoring wholesale platforms with real paying customers. Every atom was stress-tested against production data before release.

Powering NotifyBee

atoms

cognitive primitives

pure atom response time

endpoints

atoms + sift composite

Pricing

Start free. Scale as you grow.

Every atom call is metered. Pure atoms (diff, score, store, recall) are nearly free. LLM atoms (interpret, match, explain) cost per token.

Build vs. buy

~$200K+

Build it yourself

3–6 months of engineering: diff logic, LLM prompts, state management, storage, observability, and delivery.

$49/mo

SemiSift Starter

5,000 atom calls/month, 50K stored signals, ready in 5 minutes. No prompts to maintain.

Free

$0/mo

100 atom calls / month
1,000 stored signals
10 req / minute

Starter

$49/mo

5,000 atom calls / month
50,000 stored signals
60 req / minute

ProPopular

$149/mo

50,000 atom calls / month
500,000 stored signals
300 req / minute

Enterprise

Custom

Unlimited volume
Unlimited stored signals
1,000 req / minute
Dedicated support