Skip to content
New

DeepSeek V4.1 Flash free for 7 days: 10M tokens a day after a top-up of $10 or more. Until Nov 30.

How it works

Everything the model can reach before it answers.

The tools around the models. In a chat turn the model can search the public web and indexed .onion services, read a page, look up an IP, a domain or a breached email, and take apart the files you attach. What it finds comes back as numbered citations. Methodology, CVE data and the CVE to ATT&CK graph live in CKE 2.0, which has its own page.

What each tool gives you on a real job

Every entry ends with its limit, because you will hit it.

Outside sources

Writeups, changelogs, disclosures and search indexes. The model reads them and cites the URL.

Web search

web_search

Searches the public web and returns titles, URLs and page excerpts. Results from NVD, cve.org, CISA, GitHub, Seclists, PortSwigger and OWASP rank first. Use it for vendor advisories, PoC writeups and anything newer than the model.

Limit: Up to 10 results per call, cached for 15 minutes. Results can be wrong or out of date, so open the citation before you rely on it.

Page reader

read_url

Fetches one public page as text: the disclosure, the patch notes, the program policy. Requests leave through a guarded egress that checks every address and redirect and pins the connection to the checked IP.

Limit: Public http(s) on ports 80 and 443, HTML, text, JSON or XML, 10 MB and 15 seconds. It honors robots.txt. In the chat it opens only URLs you typed or that a search, CVE, advisory or CKE 2.0 result returned, so links inside a page and .onion results stay closed.

Dark web search

darkweb_search

Queries several Tor search indexes at once and returns the .onion title, URL and snippet, with the index each entry came from. Use it to find a ransomware group's leak site or a forum the public web does not list, then decide what to open yourself.

Limit: It opens only when you ask: your message has to say dark web, deep web, .onion or Tor, and naming a ransomware group is not enough. The search never opens, crawls or downloads a listed page, so each entry is unverified and possibly hostile until you read it with read_onion. Five searches a minute per user. Queries for child abuse material are refused and matching results are dropped.

Onion page reader

read_onion

Reads one .onion page over Tor and returns its text, so a leak site or a forum post found with darkweb_search can be read and cited in the chat. HTML becomes text and scripts are dropped.

Limit: Only when you ask for the dark web, and only v3 .onion addresses over Tor: no clearnet, no IP, no redirects, no cookies. Text only, so images, archives and binaries are refused. One page per call, no crawling, 60 seconds per page. Addresses and pages with child abuse indicators are refused before the fetch and dropped after it.

Network data

Lookups on the infrastructure in front of you: who holds an address, what a domain resolves to, whether a site answers. They read public registries, resolvers and databases and send nothing to the host. The port scan is the exception, and its entry says so.

IP and ASN

ip_info, asn_lookup

Geolocation, ISP, organization, ASN and hosting, proxy and mobile flags for one address or a batch, with optional reverse DNS, DNS blocklist status and the regional registry record with its abuse contact. asn_lookup goes from an IP, an AS number or an organization name to the holder and its announced networks.

Limit: Public databases lag and disagree, and a flag is a hint, not attribution. Blocklist checks cover IPv4 only.

Domains

domain_info

DNS records, registration over RDAP with registrar, dates, name servers and DNSSEC, and email authentication: MX, SPF and DMARC with pass or fail.

Limit: Public resolvers and registries only. Results are cached, so asking again right away returns the same answer.

Sites

site_check

Whether a public site answers, with status code, response time and server, and a grade of its security headers: CSP, HSTS, X-Frame-Options and the rest.

Limit: It uses the origin and one ordinary request. It grades headers and does not look for vulnerabilities.

Breach exposure

breach_check

Checks an email address against public breach data: how many breaches, which services, the risk and whether passwords were exposed.

Limit: It knows what public breach data lists. A clean result does not mean the address never leaked.

Port scan

port_scan

Which TCP ports on a public host are open, from the ports you name or a common set. A third-party scanning service runs it from its own servers, never from NotHoly infrastructure, and private, reserved and internal addresses are refused.

Limit: This is active traffic to the host, so point it only at hosts you may test. One scan per answer, and in the CLI it runs only after you confirm.

Your files

Attach the sample, the APK or the bundle. Everything is parsed statically and nothing you upload is executed.

Each file is parsed statically in a disposable gVisor container with no network, a read-only root and no secrets. Nothing in a file is executed, so analysis stops at what static parsing can see. A file over the limits or a parser failure ends as rejected with a reason.

Binaries

binary_info, disassemble

ELF, PE, Mach-O and DEX give SHA-256, entropy and strings. ELF and PE add format, entry point, sections and imported functions. High entropy and odd imports show up before you open a disassembler.

Limit: The disassembly is a preview: the first 4 KB of the file decoded as x86-64, at most 200 instructions. There is no decompiler and no control-flow graph, so keep yours open.

Archives and APKs

archive_list

zip, tar, gzip, bzip2, xz, JAR and APK are walked entry by entry, and each entry goes through the same parsers. Encrypted entries and symlinks are flagged and skipped.

Limit: Depth 3, 10,000 entries, 2 GB expanded and a 100:1 ratio. A zip bomb stops with the reason.

Text and source

file_read, file_search

Source, logs, JSON, minified bundles, PDF, Office files, HTML, XML and SVG arrive as text with a file and line locator. Word search runs across every attached file. AWS keys, GitHub tokens, Slack tokens and private keys raise a warning. Pickles are disassembled and never loaded.

Limit: 200 MB per file in the chat and 5 million characters of text. Images give dimensions only, with no OCR.

Your machine

The one place commands run, with your approval and in front of you.

Terminal agent

read, grep, glob, edit, write, bash

Reads, searches and edits your project and runs commands locally. By default it asks before every write and every command, showing the diff, and plan mode only reads. Reading outside the project asks first, opening a credential file needs the name typed back, and after a private read each outgoing query is shown to you before it leaves.

Limit: yolo asks only about credential files. It needs --yolo on every start and is off during an engagement.

Engagements

notholy engage

notholy engage init writes the scope, exclusions, time window and permission reference to your machine. While one is active the agent reads the targets out of each command before bash runs it, makes you type the host to go out of scope, and appends every decision to a hash-chained log. notholy connect claude installs the same check as a hook.

Limit: It reads the shell text and does not resolve DNS, so it catches operator mistakes and is no sandbox. A target known only at run time gets a warning for you to check.

The run

What you can see while the tools work, and what stops them.

Evidence panel

Citations open beside the answer with the URL or the file locator, tagged as observed in a file, external source, CKE 2.0 or dark web index.

Limit: A citation shows where a claim came from. Whether the source is right is still your call.

Tool timeline

Each call shows its target and duration as it happens. The run lives on the server, so a reloaded page picks up the stream where it was.

Limit: 12 model steps, 5 tool calls at a time, 60 seconds per tool and 10 minutes per run.

Projects

Group chats by engagement. Instructions and scope notes are added to every run in the project.

Limit: Notes guide the model and do not put a target in scope.

Cybersecurity Knowledge Engine 2.0

Methodology, commands and tool docs, the CVE mirror with CVSS, EPSS and KEV, and the graph from CVE to ATT&CK technique. The model queries it on its own unless you switch CKE 2.0 off in the composer.

Open CKE 2.0
  • kb_search

    Hybrid search

  • kb_read

    Hybrid search

  • cve_lookup

    CVE intelligence

  • cve_search

    CVE intelligence

  • advisory_lookup

    CVE intelligence

  • kb_related

    Entity graph

Which tools for which job

Reverse engineering
Attach the APK or the ELF. binary_info gives imports, sections, entropy and strings, archive_list walks the package, and kb_search brings the MASTG test that applies.binary_infoarchive_listfile_searchkb_search
Pentest
Paste the service banners from your scan. cve_search filters by vendor and KEV and ranks by EPSS, and kb_search pulls the WSTG procedure. The CLI agent runs your tooling on your machine once you approve the command, and notholy engage checks each one against the scope first.cve_searchkb_searchcve_lookupnotholy engage
Bug bounty
Attach the lockfile or the minified bundle from an asset in scope. advisory_lookup checks each pinned version, file_search finds endpoints and hardcoded keys, and read_url reads the program policy.advisory_lookupfile_searchread_url
Red team
kb_search with domain attack or offensive returns ATT&CK techniques and LOLBAS and GTFOBins entries with their source, so the plan cites a technique ID.kb_searchkb_read
Malware analysis
Hashes, entropy, imports and strings come out of the static parser and nothing is detonated. Archives are walked to depth 3, and web_search takes the hash or a domain from the strings.binary_infoarchive_listfile_readweb_search
Vulnerability research
cve_lookup gives the CWE and affected versions, read_url reads the advisory or the patch notes, and kb_search brings the CWE entry and the testing guide for that class.cve_lookupread_urlkb_search
OSINT and threat intel
web_search covers what is indexed in the open, and domain_info, ip_info and asn_lookup map the infrastructure behind a name. When you ask for it, darkweb_search lists .onion entries for a group or a keyword, and you open them yourself.web_searchdomain_infoip_infodarkweb_search

Where it stops

No traffic to your targets from our servers
Server tools read. None of them scans, probes or sends a payload from NotHoly infrastructure. read_url reaches public pages through the guarded egress, and port_scan, the one tool that sends traffic to a host, is run by a third-party service from its own servers.
The CLI acts on your machine
The terminal agent runs read, grep, glob, edit, write and bash locally, with your approval. In the default mode it asks before every write and every command, and plan mode only reads.
Outside content is labelled as data
Pages, files and search results reach the model wrapped in markers with a random id and marked as untrusted content.
read_url stays passive
It refuses IP literals, attack strings and exposed-file paths such as /.git and /.env, and stops after 40 distinct paths on one host in 10 minutes. A URL that carries text from a file attached to the chat is refused too.

What each surface can call

The chat decides per turn which tools to offer. The CLI, MCP and the Research API give you the same data under your own control.

Web search

Chat
web_search
CLI
agent: web_search
MCP
web_search
Research API
POST /v1/web/search

Page reader

Chat
read_url
MCP
read_url
Research API
POST /v1/web/read

Dark web search

Chat
darkweb_search
MCP
darkweb_search

Onion page reader

Chat
read_onion

Network data

Chat
ip_infodomain_infoasn_lookupsite_checkbreach_checkport_scan
CLI
agent: my_ipport_scan
MCP
ip_infodomain_infoasn_lookupsite_checkbreach_checkport_scan

CVE record

Chat
cve_lookup
CLI
notholy cveagent: cve_lookup
MCP
cve_lookup
Research API
GET /v1/cve/{id}

CVE search

Chat
cve_search
CLI
notholy cve search
MCP
cve_search
Research API
GET /v1/cve/search

Package advisories

Chat
advisory_lookup
MCP
advisory_query
Research API
POST /v1/advisories/query

CKE 2.0

Chat
kb_searchkb_read
CLI
notholy kbagent: kb_search
MCP
kb_searchkb_read
Research API
GET /v1/kb/searchGET /v1/kb/{id}

Entity graph

Chat
kb_related

File analysis

Chat
file_listfile_readfile_searchbinary_infoarchive_listdisassemble
CLI
notholy analyze
MCP
analyze_file
Research API
POST /v1/filesGET /v1/files/{id}

Local files and commands

CLI
agent: readgrepglobeditwritebash

Engagement scope and log

CLI
notholy engage

POST /v1/chat/completions, /v1/responses and /v1/messages are the raw model endpoints and have none of these tools. The model gets only the function tools you send, and your code runs them. To use this data from your own code, call the Research API or MCP.

Ask anything your scope allows.

Create an account, add credits and ask the first question in the chat or the terminal.

  1. 1/3

    Create the account

    Individual or company. You can switch to a company later without losing balance or keys.

    IndividualCompany
  2. 2/3

    Add credits

    By card. Pay per token, no subscription.

    $5.00minimum deposit
  3. 3/3

    Ask

    In the chat, or install the CLI and run notholy login in your terminal.

    $ notholy login