Skip to content
Back to search

AiSOC

Open-source AI Security Operations Center: alert fusion, LLM-agent triage, MITRE ATT&CK investigation, and a replayable decision ledger for every agent step. Self-hostable, runs with no API keys, MIT licensed. Ships an MCP server for Claude, Cursor and Continue.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/beenuar/AiSOC with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/beenuar/AiSOC'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/beenuar--aisoc/badge.svg)](/listings/beenuar--aisoc)

HTML

<a href="/listings/beenuar--aisoc"><img src="/api/listings/beenuar--aisoc/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

git clone https://github.com/beenuar/AiSOC && cd AiSOC
make up

The [Technical Guide](apps/web/public/papers/aisoc-technical-guide.pdf) covers this in depth — server sizing, where the model runs, every failure mode with its cause and fix, the REST API, MCP, and a screenshot of each console surface.

Needs Docker Compose v2 with **8 GB memory and 20 GB free disk in the Docker VM**, plus `python3` (3.9+) and `bash`; `make doctor` checks all of it and [Installation](https://beenuar.github.io/AiSOC/docs/installation#requirements) says what each number was measured against. The first run downloads a ~2 GB model into a volume only `make clean` clears.

`make up` also creates `.env` and generates the **fifteen** secrets in it — the credential vault, the session signing key, five service-to-service credentials and four datastore passwords — then creates an administrator and prints its password, generated on your machine, shown once and stored nowhere. Copy it, or mint another with `make bootstrap ARGS=--reset-password`.

**A port already in use does not stop the install.** AiSOC publishes on a free one, names what held the old one, and moves the console address with it — measured on a bare clone with 5432 and 11434 both taken, 64 seconds to a signed-in console.

Then **prove it works**. `make smoke` posts one real event to the ingest API and follows it through Kafka, detection, correlation and Postgres, then reads the alert back out of the public API. Every stage reports PASS or FAIL:

$ make smoke
[PASS] raw telemetry accepted by ingest
[PASS] event traversed the spine and became an alert
[PASS] alert is retrievable by id from the API
PASS: 10/10 stages

Sign in at the address `make up` printed. A tenant with nothing connected lands on a **setup wizard** rather than an all-zero dashboard, and its state is read from your own data so it stays right if you connect a source through the API. The spec is [`docs/openapi.yaml`](docs/openapi.yaml) — interactive docs are off in this production-class stack. Stuck? `make doctor`, which on a host where you have not run `make up` yet says exactly that.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 249 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. <img src="apps/web/public/logo-mark.svg" alt="AiSOC" width="120" />
  3. # AiSOC
  4. **An open-source, self-hostable AI Security Operations Center.** It ingests your security telemetry, detects and correlates threats, investigates them with AI agents whose reasoning is fully auditable, and proposes responses a human approves.
  5. [![License: MIT](https://img.shields.io/badge/License-MIT-22c55e.svg?style=flat-square)](https://opensource.org/licenses/MIT) [![Version](https://img.shields.io/badge/version-23.5.1-f59e0b?style=flat-square)](CHANGELOG.md) [![CI](https://img.shields.io/github/actions/workflow/status/beenuar/AiSOC/ci.yml?branch=main&label=CI&style=flat-square)](https://github.com/beenuar/AiSOC/actions/workflows/ci.yml)
  6. [![CodeQL](https://img.shields.io/github/actions/workflow/status/beenuar/AiSOC/codeql.yml?branch=main&label=CodeQL&style=flat-square)](https://github.com/beenuar/AiSOC/actions/workflows/codeql.yml) [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/beenuar/AiSOC/badge)](https://securityscorecards.dev/viewer/?uri=github.com/beenuar/AiSOC) [![Technical Guide](https://img.shields.io/badge/Technical%20Guide-28%20page%20PDF-dc2626?style=flat-square)](https://raw.githubusercontent.com/beenuar/AiSOC/main/apps/web/public/papers/aisoc-technical-guide.pdf)
  7. **[Technical Guide (PDF)](https://raw.githubusercontent.com/beenuar/AiSOC/main/apps/web/public/papers/aisoc-technical-guide.pdf)** · [Docs](https://beenuar.github.io/AiSOC/) · [Architecture](docs/architecture/README.md) · [What actually works](docs/audit/REPOSITORY_REALITY.md) · [Discussions](https://github.com/beenuar/AiSOC/discussions)
  8. </div>
  9. ---
  10. ## What AiSOC does
  11. Telemetry arrives from your security tools. AiSOC normalizes it, runs the 2966 executable rules of
  12. its 7408-rule library, groups what fires into incidents, investigates each one with an AI agent whose
  13. every prompt and tool call is recorded, and proposes an action. New threat intelligence re-sweeps the
  14. history you already collected, and a human approves before anything reaches a vendor.
  15. ## What it looks like running
  16. <a href="apps/web/public/demo/demo.mp4"><img src="apps/web/public/demo/hero.gif" alt="AiSOC on one host: the alert queue filled by the pipeline, a local-model triage verdict in the investigation rail, and the risk-based entity queue naming the hosts each entity was seen on" /></a>
  17. **[Watch the full walkthrough](apps/web/public/demo/demo.mp4)** — install to AI verdict on one server against the published images, terminal waits shortened and the recording saying so on screen. The recording and the stills below are both from a v23.5.0 run. ([step by step](apps/docs/docs/deployment/walkthrough.mdx) · [what is real](apps/web/public/screenshots/README.md))
  18. | | |
  19. |---|---|
  20. | <img src="apps/web/public/screenshots/alerts-queue.png" alt="Alerts queue" /> | <img src="apps/web/public/screenshots/ai-triage-verdict.png" alt="AI triage verdict in the Investigation Rail" /> |
  21. | **Alerts** — each attributed to the connector that fed it. | **Automated triage** — the bundled local model's verdict, confidence and rationale, verbatim. |
  22. | <img src="apps/web/public/screenshots/threat-intel-kev.png" alt="Threat intelligence page showing CISA KEV entries" /> | <img src="apps/web/public/screenshots/soc-operations.png" alt="SOC operations dashboard with honest empty states" /> |
  23. | **Threat intelligence** — the real CISA KEV catalog, minutes after boot, with no API key. | **SOC operations** — with nothing connected yet, and it says so rather than showing a placeholder. |
  24. | <img src="apps/web/public/screenshots/entity-risk-queue.png" alt="Entity-risk queue showing the hosts each entity was seen on" /> | <img src="apps/web/public/screenshots/attack-graph.png" alt="The entity attack graph over real ingested telemetry with Neo4j running" /> |
  25. | **Risk-based alerting** — alerts rolled up per entity, each row naming the hosts it was seen on. | **Attack graph** — identities, assets and IPs over real ingested telemetry, with Neo4j live. |
  26. ## Quick start
  27. ```bash
  28. git clone https://github.com/beenuar/AiSOC && cd AiSOC
  29. make up
  30. ```
  31. **On Windows**, or on a machine with nothing installed yet, one line does the prerequisites too: `iwr -useb https://raw.githubusercontent.com/beenuar/AiSOC/main/install.ps1 | iex` (`curl -fsSL https://raw.githubusercontent.com/beenuar/AiSOC/main/install.sh | bash` on Linux and macOS). **Without Docker at all**, `pip install aisoc-sandbox && aisoc-sandbox demo` walks one alert through the agent funnel offline in under 30 seconds. **Without your own machine**, open the repo in GitHub Codespaces and run `make up` in its terminal. All four end at the same console; only the first three install anything.
  32. The [Technical Guide](https://raw.githubusercontent.com/beenuar/AiSOC/main/apps/web/public/papers/aisoc-technical-guide.pdf) covers this in depth: server sizing, where the model runs, every failure mode with its cause and fix, the REST API, MCP, and every console surface.
  33. Needs Docker Compose v2 with **8 GB memory and 20 GB free disk in the Docker VM**, plus `python3` (3.9+) and `bash`; `make doctor` checks all of it and [Installation](https://beenuar.github.io/AiSOC/docs/installation#requirements) says what each number was measured against. The first run downloads a ~2 GB model into a volume only `make clean` clears.
  34. `make up` also creates `.env` and generates the **sixteen** secrets in it — the credential vault, the
  35. session signing key, five service-to-service credentials and four datastore passwords — then creates an
  36. administrator and prints its password, generated on your machine, shown once and stored nowhere. Lost
  37. it? `make bootstrap ARGS=--reset-password` mints another.
  38. **A port already in use does not stop the install.** AiSOC publishes on a free one, names what held the
  39. old one, and moves the console address with it: 64 seconds to a signed-in console on a bare clone with
  40. 5432 and 11434 both taken.
  41. Then **prove it works**. `make smoke` posts one real event to the ingest API and follows it through
  42. Kafka, detection, correlation and Postgres, then reads the alert back out of the public API. Every
  43. stage reports PASS or FAIL:
  44. ```
  45. $ make smoke
  46. [PASS] raw telemetry accepted by ingest
  47. [PASS] event traversed the spine and became an alert
  48. PASS: 10/10 stages
  49. ```
  50. Sign in at the address `make up` printed. A tenant with nothing connected lands on a **setup
  51. wizard** rather than an all-zero dashboard, and its state is read from your own data so it stays
  52. right if you connect a source through the API. The spec is
  53. [`docs/openapi.yaml`](docs/openapi.yaml) — interactive docs are off in this production-class stack.
  54. Stuck? `make doctor`, which on a host where you have not run `make up` yet says exactly that.
  55. Press **Load sample data** in the wizard. Five scenarios take the same ingest path a real connector uses — not inserted rows — so watching them become alerts means watching the pipeline work. They span low to critical on purpose, because a first run where everything is a crisis teaches you nothing about how triage separates signal from routine. They are attributed to `AiSOC` in the source column, refuse to load into a tenant that already has real alerts, and do **not** mark setup complete. ([what each step proves](https://beenuar.github.io/AiSOC/docs/console/getting-started)) For the larger fixed corpus used by demos and evals, `make demo` loads a **synthetic** dataset — the pipeline shape, never a benchmark, a customer or an incident. Every row is `is_synthetic = true` and labelled in the console.
  56. ## Connect real data
  57. Push, with a credential from `make ingest-token` (the tenant comes from it, not a header):
  58. ```bash
  59. curl -X POST http://localhost:8081/v1/ingest/batch \
  60. -H 'Content-Type: application/json' -H "Authorization: Bearer $AISOC_INGEST_TOKEN" \
  61. -d '{"connector_id":"edr-1","connector_type":"crowdstrike","events":[{"severity":"high",
  62. "title":"Encoded PowerShell from Office","host":"WIN-FIN-01"}]}'
  63. ```
  64. Or pull, by configuring one of **97 click-and-connect data connectors** in **Settings → Connectors**
  65. — Splunk, Sentinel, Elastic, CrowdStrike, Okta, AWS and Kubernetes audit among those with
  66. vendor-specific normalization and setup docs
  67. ([coverage](https://beenuar.github.io/AiSOC/docs/connectors/api-coverage)). Without a vendor profile
  68. a connector still ingests through a generic mapping that resolves host, user and source IP.
  69. **A real cloud estate does not hand you its logs over a REST call.** Four collectors read the
  70. surfaces one actually emits to: a CloudTrail organisation trail on **S3 notified over SQS**
  71. (management events, data events and VPC flow logs), a **GCP Pub/Sub** subscription on a Cloud Logging
  72. sink, an **Azure Event Hubs** capture, and a **syslog/CEF** listener. Each keeps a resumable cursor
  73. and a bounded per-poll budget, so a backlog applies backpressure instead of flooding ingest.
  74. Bringing existing detections? `packages/aisoc-migrate` translates Splunk SPL, Sentinel KQL and
  75. Elastic EQL and **refuses rather than approximating** what it cannot carry, because an almost-right
  76. rule is harder to find than a missing one: of the 2,005 Splunk rules bundled here 1,734 translate and
  77. 1,711 of those are partial ([what that means](apps/docs/docs/migration/from-splunk.md)).
  78. ## How it works
  79. Ingest normalizes to a common shape and stamps an **activity projection** on every event — actor, action, resource, location, outcome, with `actor.kind` read from each vendor's own documented field rather than inferred — then Kafka carries it.
  80. Then fusion runs 2966 executable detection rules, of 7408 on disk, plus 76 sliding-window rules (73 count across events; 3 match an ordered sequence), applies **your tenant's own tuning** on top — the disables, floors and suppressions the console writes, so a rule you turned off actually stops firing — and decides what becomes an alert.
  81. Correlation groups related alerts, an agent investigates and writes its reasoning to the Investigation Ledger, and a playbook may start from the result. Separately, new threat intelligence sweeps the lake for sightings you already collected, and a hypothesis becomes a hunt without anyone writing a query — the model fills a closed schema and every value is bound as a parameter, so it cannot express a query at all.
  82. **A playbook triggered by an alert previews before it acts.** Three switches must agree — the
  83. deployment, the tenant, the playbook — and every default is off; anything less runs in preview with
  84. its plan attached to the alert. An approval step is a durable pause: the run suspends to Postgres,
  85. survives a restart, resumes after the approval, and expires with a recorded outcome rather than
  86. hanging.
  87. **Executable is earned, not declared.** A rule joins the compiled ruleset only after a vendor-shaped
  88. event is replayed through the real connector and engine and that rule is *watched to fire* — never
  89. inferred from a directory or an `enabled:` flag. The proof can fail: `--prove-gate` reverts the
  90. Windows connector and requires all 1,687 Windows rules to go silent. It means reachable, not that it
  91. detects an attack. **Two** rules still cannot fire — down from 119, because a rule that could not fire
  92. stopped being counted as executable — and both are waiting on a behavioural baseline. The ratchet
  93. only moves down. ([why 1,362 were refused](docs/detections/sigma-compilation.md))
  94. **Every answer carries its receipts.** The copilot cites each checkable claim to the ledger entry behind
  95. it and labels the rest *uncited* rather than dropping them, and any investigation exports as a **signed
  96. evidence bundle** — byte-identical, prompts as digests, OCSF 1.9.0. ([how](docs/architecture/evidence-bundles.md))
  97. **Where state lives.** Twenty service trees (14 Python, 4 Go, 2 TypeScript) behind the Next.js console. Kafka is the
  98. spine; Postgres holds the alerts, cases and the tamper-evident audit chain; Redis and Qdrant are in CORE too, and
  99. `full` adds ClickHouse (the event lake), Neo4j (the entity graph) and OpenSearch (full-text search).
  100. **[docs/architecture/README.md](docs/architecture/README.md)** walks that path one step at a time —
  101. eleven steps, five diagrams, every box linking to the code — and [mirrors to the docs portal](https://beenuar.github.io/AiSOC/docs/architecture).
  102. ## Deployment profiles
  103. | Profile | Command | Services | RAM | What you get |
  104. |---|---|---|---|---|
  105. | **core** | `make up` | 16 | ~8 GB | The full alerting pipeline: ingest → detect → correlate → alert → triage → console, plus the LLM gateway, a local model, the CISA KEV threat feed, and the connector and response services the agent's vendor tools reach |
  106. | **full** | `make up-full` | 22 | ~12 GB | Core plus event lake, entity graph, full-text search, enrichment |
  107. | **demo** | `make up && make demo` | 16 | ~8 GB | Core plus labelled synthetic data |
  108. CORE is the smallest deployment that takes a real event and produces a real alert, and **it needs no
  109. credentials to do either.**
  110. **The model ships with the gateway.** Ollama runs a pinned ~2 GB `llama3.2:3b-instruct-q4_K_M`
  111. sized for CPU-only inference, so `make up` produces real triage verdicts with real token counts in
  112. the Investigation Ledger — not a stub. It is not a frontier model: over 50 alerts it gave triage
  113. usable output 44 times before the reply was constrained to JSON and 50 after
  114. ([method](scripts/measure_triage_reliability.py)), and the rail labels which path answered. Run it
  115. faster with `make up-gpu`, `make up-host-llm`, or your own provider from the console
  116. ([all four](apps/docs/docs/operations/where-the-model-runs.md)). **No hosted provider has ever been
  117. exercised here** — there is no funded key, so per-model rows read *not measured* rather than zero.
  118. ([ADR-0006](docs/decisions/0006-llm-gateway-in-core.md))
  119. **One real external feed ships too.** `services/threatintel` polls the CISA Known Exploited
  120. Vulnerabilities catalog — public, no API key — into the console's Threat Intelligence page: the one
  121. thing in a fresh install that is neither synthetic nor yours.
  122. ## Evaluation, reflex and replay
  123. The published numbers carry their own provenance. ([methodology](https://beenuar.github.io/AiSOC/docs/benchmark) · [real vs synthetic data](apps/docs/docs/concepts/real-vs-synthetic.md))
  124. - **Every verdict scorecard names the model that actually served it** — gateway-attested or self-reported, with an explicit provenance status. A run with missing attribution, zero real calls or a deterministic fallback cannot be advertised as a named model's performance, and a measurement that cannot be bound to an attributed call cannot authorize closures.
  125. - **Denominators are published, and the uncomfortable direction wins.** Full-cohort recall keeps abstentions and failures in the malicious denominator; closure claims ship with their contamination rate; alert reduction has three labelled figures (75.3% legacy grouping, 33.3% production key, 24.5% on a detection-shaped cohort after a missing identifier was fixed to *narrow* the group instead of widening it). Unmeasured reads *not measured*, never `0`.
  126. - **The reflex path is observable** — nine named stages from queue delay to verification, and a decision contract carrying supporting evidence, contradictory evidence, missing prerequisites and the escalation reason.
  127. - **Replay is time-frozen; re-hunting is labelled.** Historical replay enforces evidence cutoffs in the retrieval queries (never by prompt), discloses the model-knowledge limit, and cannot execute real actions — the mutation boundary is the write adapter. Applying new intelligence to old telemetry is a distinct, rehearsable mode, and its discoveries are never counted as predictions at the original event time.
  128. - **Model suitability is per task.** The matrix grades each configured model on the same locked evidence against a deterministic baseline floor (balanced accuracy exactly 0.250); unfunded rows read *not measured*, with one-command reproduction against any local OpenAI-compatible endpoint.
  129. ## AI agents
  130. Agents triage alerts and investigate incidents. What they can and cannot do:
  131. - **They read** the alert, its correlated siblings, entity context, and prior verdicts for the same signature.
  132. - **They call typed tools** — lake queries, graph traversals, enrichment lookups. The model picks the tool and passes arguments; it never writes SQL.
  133. - **Everything is logged** to the Investigation Ledger — prompts, tool calls, citations, verdict, token cost — and exports as a signed bundle.
  134. - **Grounding is checked.** A verdict citing an indicator the evidence never contained is demoted to human review rather than auto-closed.
  135. - **A prompt is validated before it is sent.** Raw logs, OCSF payloads and secret-shaped values are refused, not redacted after the fact.
  136. - **No vendor is touched without a human**, unless a tenant has explicitly granted autonomy for that verb. Every response step is graded against its own capability contract at dispatch, so approving a playbook never authorises whatever its steps happen to contain, and an approver must hold the required permission tier and must not be the person who requested the action.
  137. ## Project maturity
  138. **Stable is defined, and a gate enforces it.** It was ungated prose until three rows were found describing coverage that did not exist. A row is Stable only with a check that runs on every pull request with no path filter, drives the real production path against real infrastructure, and has a **negative control proven by breaking the thing and watching it go red**. ([the bar](docs/audit/MATURITY_DEFINITION.md))
  139. | Capability | Status | Tested | Production ready |
  140. |---|---|---|---|
  141. | Ingest → detect → correlate → alert | Stable | E2E + unit | Yes |
  142. | Detection engine (2966 executable rules) of 7408 | Stable | Replay proof | Yes |
  143. | Alert correlation into incidents | Stable | Unit | Yes |
  144. | REST API + web console | Stable | Unit + integration | Yes |
  145. | AI triage + Investigation Ledger | Stable | Live Postgres ledger + a PR-gated local-model agent run. No hosted provider has been exercised | Yes, copilot mode |
  146. | Event lake + hunting (ClickHouse) | Stable | Live ClickHouse on the shipped DDL, with a negative control | Yes, `full` profile |
  147. | Retro-hunts when new intel arrives | Stable | Live ClickHouse + Kafka with the flag on, with a negative control | Opt-in, `full` profile |
  148. | 68-hunt YAML library, compiled against tenant events in the lake | Stable | Live ClickHouse: scheduled hunts read tenant data and refuse to fall back to the fixture; all 114 field names the corpus filters on compile, via a lake column or the stored payload | Yes, `full` profile |
  149. | SCIM 2.0 provisioning | Stable | Live Postgres through the real app: PATCH in both providers' dialects, group membership, deprovisioning proved by its consequences, with a negative control | Yes |
  150. | White-label branding | Stable | Live Postgres: the scheduled report and its covering email carry the organisation's brand, with two negative controls | Yes |
  151. | Usage metering | Stable | Live ClickHouse on the shipped DDL, with a negative control that makes an unscoped meter fail | Yes |
  152. | Entity graph (Neo4j) | Stable | Live Neo4j against the production reader, with a negative control | Yes, `full` profile |
  153. | Governed response actions | Stable | Live socket: permits, refuses, never leaks a refusal, with a negative control | Human-approved only |
  154. | Alert-triggered playbooks, with a durable approval pause | Stable | Live Postgres: suspend, restart, resume, expiry, with a negative control | Yes — three opt-ins deep, preview by default |
  155. | Per-tenant detection tuning in the live engine | Stable | Live Postgres: tuning written changes what the engine fires, with a negative control | Yes |
  156. | Scheduled connectors | Stable | Live scheduler polls a stub vendor into ingest, with a negative control | Yes |
  157. | UEBA | Stable | Live Postgres: migrations, scoring, persistence, isolation, with a negative control | Yes, `full` profile |
  158. | Package distribution (npm/PyPI) | Beta | The five PyPI packages resolve at the tree's versions, checked against the live registries in both directions with a self-test; the npm half has no registry state to verify | `pip install aisoc-sandbox` (and the other four) works today; the three npm packages still need the first-upload `NPM_TOKEN`, an account action |
  159. ## What AiSOC is not
  160. - **Not a drop-in SIEM replacement.** It correlates and investigates; it does not replace long-term log retention and compliance search.
  161. - **Not able to see telemetry you have not connected.** There is no discovery.
  162. - **Not autonomous by default.** Response requires explicit policy authorization and a human approver.
  163. - **Demo and sample incidents are not real incidents**, and benchmark numbers are substrate self-consistency measures, not live agent accuracy — labelled as such wherever published.
  164. ## Troubleshooting
  165. `make doctor` checks host tools, memory, disk, every port and each datastore by *querying* it rather than asking whether its container is up, then prints the command to run next. A container killed by a full Docker VM is named as that, not as the service that happened to die.
  166. ([the six most common failures](https://beenuar.github.io/AiSOC/docs/installation#the-six-most-common-failures))
  167. ## Security
  168. Secrets are generated per deployment and never committed; connector credentials are encrypted at rest. Services connect to Postgres as a DML-only role, so row-level security actually applies, and tenant isolation is enforced at the query layer in every store. RBAC gates every mutating route, ingest is authenticated, and the default install sends no prompt anywhere — the model runs beside it.
  169. SAML and OIDC sign-in with per-connection tenant and group mapping, SCIM provisioning, and console
  170. **MFA** — TOTP with recovery codes, enforceable per tenant. Attribute conditions, time-boxed
  171. elevation and workload identities run inside the one permission path, where a condition can only
  172. narrow a permission and never grant one. ([SSO](apps/docs/docs/operations/enterprise-sso.md) ·
  173. [access governance](docs/security/access-governance.md))
  174. **A service with no credential refuses to serve rather than serving unauthenticated.** The [changelog](CHANGELOG.md) records each fix; report via [SECURITY.md](SECURITY.md).
  175. ## Developing
  176. ```bash
  177. make test # unit tests for every service
  178. make smoke # the golden pipeline, against a running stack
  179. make stats # recount every figure this README publishes
  180. ```
  181. Guides: [add a connector](https://beenuar.github.io/AiSOC/docs/plugins/hello-plugin) · [add a detection](https://beenuar.github.io/AiSOC/docs/detections/hello-hunt) · [plugin lifecycle](https://beenuar.github.io/AiSOC/docs/plugins/lifecycle). Every count above is recounted from the tree, and CI fails if this README disagrees.
  182. ## Funding · Roadmap · Contributing · License
  183. Development is funded and supported by **[Cyble](https://cyble.com)**, who pay for the engineering time behind AiSOC and release it under the MIT licence rather than keeping it. That buys no special treatment here — no Cyble-only features, no gated modules, no telemetry. ([full credits](.github/CREDITS.md))
  184. [ROADMAP.md](ROADMAP.md) · [CONTRIBUTING.md](CONTRIBUTING.md) · [SECURITY.md](SECURITY.md) · MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.