Watch the feeds.
Filter to your stack.
Alert the owner.

Why not Dependabot

Because you should run both. They answer different questions.

The others start from your code and look outward. Atalaia starts from the feed and looks inward: it is watching the stream of everything published, not the contents of your lockfile, and the work it does is deciding which of that stream is yours. Dependabot will not tell you at 09:00 that the thing on Hacker News touches four of your services. Atalaia will not upgrade them for you.

The rest of the difference is disposition. It is read-only by construction, it runs on your hardware, it holds no telemetry, and when it does not know something it says so — a feed returning nothing is EMPTY, not healthy; a version it cannot compare is unknown with a reason; a repository nobody has scanned says so rather than reading as clean.

What it does

• Stack-aware filtering — the CVEs that touch your technologies, with the rest one click away
• Read-only GitHub import — several organizations, each with its own token; dependencies parsed from 12 ecosystems
• Repository correlation — which repository a CVE lands in, and through which manifest file
• Triage where you already are — Slack Block Kit and Telegram, both with Acknowledge and Resolve buttons
• Weekly digest — severity-grouped, by email and to a chat
• Plain-English explanations — optional, from a local model (Ollama, LM Studio) or a hosted one
• Console and CLI — a React console and an Ink terminal dashboard
• Twelve tools for agents at /mcp, all reads bar the one that asks a model for an explanation, behind a key of their own
• Durable jobs — feed cycles, scans and freshness checks in a worker, queued in Postgres
• Passkeys — no shared console password, with recovery codes

Is this AI slop?

Most of Atalaia was written by a language model under my direction, and I would rather you heard that from me than worked it out from the commit history. For a lot of projects that is a footnote. For a vulnerability scanner it is not: one that quietly misses things is worse than none at all, because it replaces "I do not know what I am exposed to" with false confidence.

So the useful question is not whether a model typed the code. It is what stops the output from being wrong.

Nothing that decides is generated. Severity, CVSS, exploited status and advisory links are read from the feed and stored as they arrived. No model ranks, scores, filters or de-duplicates anything. A model is asked for three things, all of them prose, all of them after triage — grep -rln "createLLMAdapter" src/ returns four files, and the fourth is the adapter. Where that prose appears it is labelled written by a model or from the advisory, from one definition every channel reads.

Read-only is enforced, not promised. A test greps the GitHub provider for write calls and asserts every request goes through the single GET helper, so no future method can route around it.

I read all of it, slowly, and more than once for anything in the correlation path. Any mistakes left in the codebase are mine.

That is the honest list, and it is shorter than I would like. Correlation currently matches CVEs to repositories by package name rather than by advisory version range; most parsers are untested. Both are written up, with the rest of what I do not claim, in docs/correctness.md — along with the commands to check any of it yourself.

Run it

Containers: Docker with Compose v2, or Apple's container on macOS 15+. One Postgres, anywhere you like.

git clone https://github.com/jacksonfdam/atalaia.git
cd atalaia

docker run -d --name atalaia-db -e POSTGRES_PASSWORD=postgres -p 5432:5432 postgres:17
echo "DATABASE_URL=postgresql://postgres:postgres@127.0.0.1:5432/postgres" >> .env

./scripts/atalaia.sh up

Ten seconds to a working console once the images are built, and about the same again to build them. The launcher creates .env from .env.example, generates the secrets that have no sensible default (API_KEY, SETUP_PASSWORD), applies the migrations, starts the three containers and waits until they answer.

  API      http://localhost:3000        (health: /health)
  Console  http://localhost:3001        (sign in with a passkey)
  Worker   no port — it takes jobs off the queue

Any Postgres 13+ works: a container like the one above, a managed instance, or a local Supabase stack (supabase start, this repository's is on port 54622) if you want the studio alongside it. Atalaia uses none of Supabase's own features — it needs a connection string.

The console has no password. SETUP_PASSWORD creates the first account and stops working the moment it has; from then on it is passkeys, with recovery codes for the day a device is lost — docs/authentication.md.

Slack, Teams, Telegram, email and model explanations all stay off until you configure them, from the console.

./scripts/atalaia.sh status              # health of each service
./scripts/atalaia.sh logs atalaia-worker # follow the worker
./scripts/atalaia.sh doctor              # runtime, database, configuration
./scripts/atalaia.sh down                # stop everything

Apple's runtime, scaling the worker, and developing against the stack are in docs/running.md.

Documentation

The same pages, rendered: atalaia-console.vercel.app.

Everything else lives in docs/: running, configuration, authentication, security, correctness, queues, sources, repositories, notifications, console and CLI, architecture, REST API, MCP server and troubleshooting.

Contributing

A new feed, ecosystem, notification channel or model provider is one file and one line in a registry. CONTRIBUTING.md has the shape of the codebase and the four things it will not do.

Security issues go through private reporting, not an issue.

Credits

Created by Jackson Mafra — Mobile and Security Engineer. Built and maintained solo since September 2025.

License

MIT — see LICENSE.