In private betaBuilt for SOC and MSSP teams

Every log source, normalised. Even the ones with no parser.

Vritta identifies each stream, maps it to OCSF, and drafts a parser for anything new. A person approves it. Self-hosted, between the collectors you run and the SIEM you keep.

  • Self-hosted, air-gapped if you need it
  • OCSF output
  • No parser activates without a person
  • Runs with no language model
Interactive· sample data, nothing leaves this page

Acme Corp

Dashboards

Event volume, what it is, and how well it parses.

Events2.42M▲ 4.2% vs 2.32M the 24 hours before
Average rate28.0/sfrom 14 sources
Parse success99.5%▼ 0.3 pts of records with a spec
Events over time· by source · 30 minutes
75k50k25k0
12:0016:0020:0000:0004:0008:0012:00
By source· the busiest eight, and the rest together
zeek_conn217,906 · 9.0%
zeek_dns58,114 · 2.4%
Everything else38,913 · 1.6%
By OCSF class· what the events are
DNS Activity (4003)158,114 · 6.5%
HTTP Activity (4002)71,502 · 3.0%
Base Event (0)46,380 · 1.9%
User Management (3007)45,246 · 1.9%
Parse outcomes· every raw record, by what became of it
ParsedGeneric (a base event, no spec)SkippedUnparsed (no source yet)FailedParse success
150k75k0100%95%
12:0018:0000:0006:0012:00
Events by tenant· every tenant you may read
acme 2.42Mglobex 1.07Mdemo 212k
60k30k0
12:0000:0012:00

Over 24 hours, compared with the 24 hours before. ClickHouse took 46 ms at most per chart, reading 3,412,880 rows.

Volume, coverage and parse outcomes across every source.Try it:

The problem

Parsers are written by hand. And they break quietly.

Before any detection can happen, every log has to be identified, parsed and mapped to a common schema. That work is manual, and it is never finished.

01 New source

Nothing parses until someone writes a parser.

A source nobody has a parser for arrives. Someone finds or writes one, maps its fields and deploys it. Until then, its events cannot be searched or detected on.

/var/log/authgw/auth.log

No parser
ts=2026-09-24T08:11:47.717+01:00 app=authgw node=gw-02 evt=login_fail user=niamh.kelly@corp.example src=10.20.2.76 mfa=webauthn reason=bad_password session=cb1a806b1dfaaffc
Client Awritten by handvendor upgradeno alertnoticedweek 0481216
Weeks before anything parses
2
Events parsed meanwhile
0%

02 Vendor upgrade

An upgrade breaks it. Nobody is told.

The vendor changes the format. The parser stops matching, the events fall through, and nothing raises an alert until someone notices the gap and fixes it by hand.

Client Awritten by handvendor upgradeno alertnoticedweek 0481216
Events parsed after the upgrade
6%
Weeks until someone noticed
4
Alerts raised
0

03 Every client

Then again, for every tenant.

An MSSP runs the same treadmill once per client: its own parser to write, its own upgrade to miss, its own fix.

Client Awritten by handvendor upgradeno alertnoticedClient BClient Cweek 0481216
Weeks of hand work
12
Weeks broken, unnoticed
15
Alerts raised
0

04 With Vritta

The same weeks, without the treadmill.

Catalog sources parse from the start, and a new one parses once its drafted spec is approved. An upgrade raises a parse rate alert when it lands, and every record that did not parse is kept raw and replayed once the fix is approved.

See a parse rate alert in the console
Client Acatalog specparse rate dropped: alertfix approved, backlog replayedClient BClient Cno catalog spec: drafted, approved, replayedweek 0481216
Weeks of hand work
0
Weeks broken, unnoticed
0
Alerts raised
3

Share of each client's events that parse, week by week. An illustration of the pattern, not measured data.

How it is different

Each model does one job. Plain code does everything else.

Language models can read an unknown log, but they are too slow and costly to run on every event, and too risky to emit code for a security pipeline. Small classifiers are fast, but they do not say when they are guessing. Vritta uses each where it is good.

  1. Every event

    Deterministic code. The hot path, in Go. It decodes, parses with an approved spec, maps to OCSF and stores.

    Trusted with
    Every record, at full volume, the same way every time.
    Never asked to
    Guess. Patterns are RE2 only, with capped steps and a time budget per record, and a spec cannot reach the network or storage.

    840 records parsedin the walkthrough tenant

  2. Once per new stream

    Laya, a small calibrated model. 421 million parameters, on CPU. It answers one bounded question for each new stream signature, and the answer is cached.

    Trusted with
    Which catalog source this is, with a probability that means what it says.
    Never asked to
    Force the closest parser. Below the threshold, or on “none of these”, the stream is marked unknown.

    5 streams classifiedin the walkthrough tenant

  3. Rarely

    A language model. The bundled local model, or an endpoint you configure. Called only for a stream that nothing in the catalog explains.

    Trusted with
    Reading redacted samples and drafting a declarative spec, constrained to a JSON Schema.
    Never asked to
    Run code, see raw values, or activate anything. Every draft is replayed against real records, and a person approves it.

    2 drafts requestedin the walkthrough tenant

Counts are for the synthetic tenant in the walkthrough below: one dot per record, per stream classified, and per draft requested.

How it works

One record, followed through Vritta. From raw bytes to an approved parser.

A synthetic tenant with five streams, one of which no parser has ever seen. Every panel is computed from its records.

01 Intake

Stored raw before anything else happens.

A collector sends a batch. Each record gets a tenant, a receive time and a stable ID, and is written raw before the batch is acknowledged. The ID hashes the tenant, the file offset and the bytes, so a retry is stored once.

  1. CollectorVector tails the log file
  2. Intaketenant demo
  3. ClickHouseraw table, written first
  4. Acknowledgedonly after the write returns

/var/log/authgw/auth.log

ts=2026-09-24T08:11:47.717+01:00 app=authgw node=gw-02 evt=login_fail user=niamh.kelly@corp.example src=10.20.2.76 mfa=webauthn reason=bad_password session=cb1a806b1dfaaffc
event id
evt_0f9ec7592d208b33
received
2026-09-24T07:11:48.129Z
state
stored raw, unparsed

02 Sniff

Nobody declares a format.

The sniffer reads the bytes, and a collector's hint wins when there is one. Highlighted: what it keyed on.

  • Windows event JSON{"@timestamp":"2026-09-24T07:07:00.628Z","winlog":{"channel":"Security","provider_name":"Microsoft-Windows-Security-Auditing","event_id":4624,"computer_name":"WS-FIN-028.corp.example","event_data":{"TargetUserName":"maeve.nolan","IpAddress":"10.20.8.176","LogonType":"3"}},"message":"An account was successfully logged on."}JSON with a winlog object
  • syslog RFC 3164<14>Sep 24 08:07:09 pa-edge-01 1,2026/09/24 08:07:09,013201001234,TRAFFIC,end,2561,2026/09/24 08:07:09,10.20.3.91,198.51.100.36,0.0.0.0,0.0.0.0,allow-web,,,ssl,vsys1,trust,untrust,ethernet1/2,ethernet1/1,log-fwd,2026/09/24 08:07:09,38217,1,54310,443,0,0,0x400000,tcp,allow,18333priority, then a BSD timestamp
  • syslog RFC 5424<38>1 2026-09-24T08:07:01.803+01:00 bastion-01 sshd 18177 - - Failed password for invalid user admin from 203.0.113.131 port 55281 ssh2priority, then version 1
  • JSON{"uuid":"bacaa3bc-c19e","published":"2026-09-24T07:07:06.502Z","eventType":"user.session.start","actor":{"type":"User","alternateId":"niamh.kelly@corp.example"},"client":{"ipAddress":"10.20.7.11"},"outcome":{"result":"SUCCESS"}}parses as a JSON object
  • key=valuets=2026-09-24T08:11:47.717+01:00 app=authgw node=gw-02 evt=login_fail user=niamh.kelly@corp.example src=10.20.2.76 mfa=webauthn reason=bad_password session=cb1a806b1dfaaffckey= before most values
  • CEFCEF:0|Imperva Inc.|SecureSphere|14.7|Signature violation|Signature violation|High|src=198.51.100.23 dst=10.20.3.14 dpt=443 act=blocked cs1=SQL injectionstarts with the CEF header
  • delimited2026-09-24 08:14:07,proxy-2,ALLOW,10.20.4.17,cdn.example.net,443,GET,200,5120a steady comma count
  • free text10.20.6.41 - - [24/Sep/2026:08:14:08 +0100] "GET /healthz HTTP/1.1" 200 2 "-" "kube-probe/1.30"no structure found

03 Streams

Grouped into streams, not split by every change.

Records group by transport, format and a cheap discriminator. New message types become shape variants inside a stream instead of splitting it. The unknown stream is buffering a sample: 200 records, stored raw meanwhile.

Open Streams in the console
  1. Windows SecurityWindows event JSON · beats:5044294 · 3 shapesknown
  2. Unknownkey=value · /var/log/authgw/auth.log200 · 3 shapessampling
  3. PAN-OS trafficsyslog RFC 3164 · syslog:udp/514191 · 1 shapeknown
  4. Linux sshdsyslog RFC 5424 · syslog:tcp/6514107 · 2 shapesknown
  5. Okta System LogJSON · okta:system-log48 · 1 shapeknown

04 Classify

Known, or honestly unknown.

Once per stream, not once per event, Laya picks a catalog source or answers “none of these”. Here no source clears the threshold, so Vritta does not force the closest parser onto it.

Stream authgw · key=value

Unknown
  1. None of these0.64
  2. Okta System Log0.14
  3. Linux auth and sshd0.11
  4. Entra ID sign-in0.07

Sample model output, not computed on this page. For contrast, the Windows stream scored 0.99 and parsed at once.

05 Draft

Drafted from redacted samples. Proved on real ones.

A language model drafts a declarative spec. Each draft is replayed against the 200 buffered records, and failures go back, redacted, for another round.

Open Proposals in the console

Draft 0.1 replayed, one cell per record

parsed 172no timestamp format 14no class for mfa_timeout 14

Returned to the model, redacted

  • 14 records: timestamp matched no declared format, e.g. ts="2026-09-24 08:09:07"
  • 14 records: class lookup has no case for evt=mfa_timeout
  • device.hostname is the constant "host-fe47", a value seen in 92 samples; map it from a field

Draft 0.2 replayed

parsed 186parsed, time zone flagged 14

Records parsedbar ≥ 95%
0.186%
0.2100%
Timestamps readbar ≥ 99%
0.193%
0.2100%
Required OCSF attributesbar ≥ 100%
0.1100%
0.2100%
OCSF violations
0.1: 00.2: 0bar 0
Sample values copied into the spec
0.1: 10.2: 0bar 0

06 Approve

It meets the bar. It still waits for you.

Nothing activates until a person approves it. Approval replays the stream's backlog through the spec, so the records kept raw become OCSF events like this one.

Approve it in the console
Samples
200, redacted before drafting
Parsed
100%
Flagged
14 with no time zone, read as UTC
Kept unmapped
session

Raw, as stored

ts=2026-09-24T08:11:47.717+01:00 app=authgw node=gw-02 evt=login_fail user=niamh.kelly@corp.example src=10.20.2.76 mfa=webauthn reason=bad_password session=cb1a806b1dfaaffc

OCSF Authentication, after approval

{ "class_uid": 3002, "class_name": "Authentication", "category_uid": 3, "activity_id": 1, "type_uid": 300201, "status_id": 2, "severity_id": 3, "time": 1790233907717, "metadata": { "uid": "evt_0f9ec7592d208b33", "version": "1.3.0", "original_time": "2026-09-24T08:11:47.717+01:00", "product": { "name": "authgw" } }, "device": { "hostname": "gw-02" }, "user": { "email_addr": "niamh.kelly@corp.example" }, "src_endpoint": { "ip": "10.20.2.76" }, "status_detail": "bad_password", "auth_factors": [ { "factor_type": "webauthn" } ], "unmapped": { "session": "cb1a806b1dfaaffc" } }

Privacy by construction

What the model sees. Placeholders, not your values.

Samples are redacted before they leave the pipeline. Keys, delimiters and timestamps survive, so the model can still read the structure. People, hosts, addresses and secrets do not.

Drag to compare. 4 of 9 values replaced; keys, timestamps and the event survive.
The record as stored, and as sent to the model
FieldStoredSent to the model
ts2026-09-24T08:11:47.717+01:002026-09-24T08:11:47.717+01:00
appauthgwauthgw
nodegw-02host-fe47
evtlogin_faillogin_fail
userniamh.kelly@corp.example<email:12b0>
src10.20.2.7688.226.114.173
mfawebauthnwebauthn
reasonbad_passwordbad_password
sessioncb1a806b1dfaaffc<redacted>
  • Keyed placeholders. From a keyed hash with a secret generated at install, so they cannot be reversed by trying every address.

  • Validated locally. Drafts are validated against the unredacted samples, on your machine. Feedback to the model is redacted the same way.

  • Every payload logged. Every payload sent to the model is logged, and you can read exactly what left.

  • No model required. The bundled local model or an endpoint you configure. With none, Vritta still classifies, parses and stores; only drafting is off.

What comes back

A parser is a spec. Readable, versioned, reviewed.

specs/authgw.jsonMeets the bar
{
  "source": "authgw",
  "version": "0.2-draft",
  "decoder": "kv",
  "timestamp": {
    "field": "ts",
    "formats": [
      "rfc3339",
      "local-datetime"
    ],
    "missing_zone": "flag"
  },
  "class_lookup": {
    "field": "evt",
    "cases": {
      "login_ok": {
        "class_uid": 3002,
        "activity_id": 1,
        "status_id": 1,
        "severity_id": 1
      },
      "login_fail": {
        "class_uid": 3002,
        "activity_id": 1,
        "status_id": 2,
        "severity_id": 3
      },
      "mfa_timeout": {
        "class_uid": 3002,
        "activity_id": 1,
        "status_id": 2,
        "severity_id": 2
      },
      "logout": {
        "class_uid": 3002,
        "activity_id": 2,
        "status_id": 1,
        "severity_id": 1
      }
    }
  },
  "map": {
    "metadata.product.name": "app",
    "device.hostname": "node",
    "user.email_addr": "user",
    "src_endpoint.ip": "src",
    "status_detail": "reason",
    "auth_factors": "mfa"
  }
}

Catalog

Starts with the sources most teams send first.

The planned v1 catalog. Each spec ships with fixture samples and expected output. Anything else goes through the proposal loop, and a spec approved for one client can be promoted to every client, with its fixtures redacted first.

  • Windows

    Windows Security and Sysmon, as Windows event JSON through Winlogbeat and the edge Vector, or Fluent Bit.

    Maps to OCSF classes: Authentication · Account Change · Process Activity · Registry Key Activity

  • Linux

    auth and sshd, and auditd: syslog RFC 3164 and 5424 or key=value, from Vector, Fluent Bit or syslog.

    Maps to OCSF classes: Authentication · SSH Activity · Process Activity · File System Activity

  • Web servers

    Apache and Nginx access logs in free text, tailed from files by Vector or Fluent Bit.

    Maps to OCSF classes: HTTP Activity

  • Firewalls

    PAN-OS, FortiGate, Cisco ASA and pfSense: syslog with delimited or key=value payloads, sent to the edge Vector.

    Maps to OCSF classes: Network Activity

  • Cloud and identity

    AWS CloudTrail, Okta, Entra ID and Microsoft 365, and Kubernetes audit, as JSON through built-in pull connectors. CloudTrail also through Vector from S3 and SQS.

    Maps to OCSF classes: Authentication · API Activity

  • Network sensors

    Zeek and Suricata, in JSON or delimited logs, tailed from files by Vector or Fluent Bit.

    Maps to OCSF classes: Network Activity · DNS Activity · Detection Finding

Planned coverage, not shipped yet. See how the console resolves a tenant's catalog

Deployment

One Compose file on one VM. Air-gapped if you need it.

It sits between the collectors you run and the SIEM you keep. Raw and normalised events stay in your ClickHouse, with tenant boundaries between clients.

Your collectors

Vector, Fluent Bitsyslog to the edge VectorPull connectors: Okta, Entra ID, CloudTrail

Your network · one node

Vritta
  1. Intake and sniffing
  2. Laya classifier, on CPU
  3. Proposal agent, local model or yours
  4. Approval and audit
ClickHouse · raw and OCSF events

The SIEM you keep

WebhookS3-compatible storageSplunk, Elastic, Security Lake: after v1

Held to these numbers

Throughput
10,000events/ssustained for 24 hours on one node, no acknowledged event lost
Ingest to searchable
≤60sat p99
Search
≤5sa filtered search over 7 days of one tenant, at p95
Day-one coverage
≥80%of a pilot's volume normalised through catalog specs
Parse success
≥99%on catalog sources
Install
≤1hourfrom a fresh install to the first normalised event
Throughput on one nodeevents per second
10,000 for 24 h

The shaded band is the v1 envelope, 5,000 to 10,000 per second. At 10,000 a second that is 864,000,000 events a day.

New source to active parserminutes, median targets
With a GPU≤ 25
CPU onlytens

drafting and validation, the reviewer's decision, open-ended on CPU. Recommended: one 16 GB GPU on 8 vCPU and 32 GB of RAM.

Storage per dayGB, at 100 GB of raw input
Raw input100
On disk20–30

Raw and normalised events in ClickHouse, an estimate the load test confirms. Thirty days of retention is roughly 1 TB of NVMe.

Questions

Before you ask.

Something else? Write to info@artisai.ie.

Do our logs leave our network?

No. Vritta runs on your infrastructure and works with no outbound access. The only thing that can leave is a redacted sample sent to a model endpoint you configure, and every payload sent is logged.

Does it replace our SIEM?

No. It sits between the collectors you run and the SIEM you keep. It normalises events to OCSF and forwards them through a webhook or S3-compatible storage. Named Splunk, Elastic and Security Lake forwarders are planned for the release after v1.

What happens to a source Vritta does not recognise?

Its records are stored raw, nothing is dropped, while Vritta buffers a sample. A language model drafts a spec from redacted samples, the draft is replayed against the real records, and once a person approves it, the backlog replays through it.

Can a language model change our pipeline?

No. A model only drafts a declarative spec, constrained to a JSON Schema. A spec cannot run code or reach the network or storage, every draft is validated against your records locally, and nothing activates until a person approves it.

What if a vendor changes its log format?

New message types become shape variants inside the stream rather than splitting it, and the stream monitor raises a parse rate alert when records stop matching their spec. Records that do not parse are kept raw, so they replay once a fix is approved.

Which collectors does it work with?

The ones you already run: Vector and Fluent Bit, Winlogbeat through the edge Vector, and syslog to the edge Vector. Okta, Entra ID and Microsoft 365 have built-in pull connectors, and CloudTrail also arrives through Vector from S3 and SQS.

Can an MSSP run it for many clients?

Yes. Each client is a tenant, with its records kept separate. A spec approved for one client can be promoted to every client, with its fixtures redacted first.

What does it need to run?

One Compose file on one VM, air-gapped if you need it. We recommend one 16 GB GPU on 8 vCPU and 32 GB of RAM; on CPU alone, drafting a new spec takes tens of minutes. With no model at all, Vritta still classifies, parses and stores.

Book a demo

Walk through it with us. Then decide about a pilot.

Tell us about your team and the sources that give you the most trouble. We reply from info@artisai.ie to find a suitable time.

  • A walkthrough of the design and whatever is running
  • Your collectors, volumes, tenants and SIEM
  • What a pilot on your data would look like

Prefer email? Write to info@artisai.ie with your name, company and team.

We reply to this address and use it for nothing else.

Your team

Optional. The sources you struggle with, the SIEM you forward to, how many tenants.

We use these details to reply and to arrange the demo. Privacy notice: who holds the data, why, for how long, and how to have it deleted.