Token LabSearch

DNS / AI OPERATIONS

AI for DNS: configuration, security, inspection and observability

Where AI improves DNS operations, why rules remain essential, and how to build an evidence-based change and diagnosis workflow.

Sources & version details
In this article

1. What AI actually adds to DNS

DNS maps names to addresses, mail routes and service information. A record change can affect website traffic, certificate issuance, email, internal discovery and security controls at once. This article follows the launch of api.example.com through configuration, security, inspection and observability. It is for developers, SREs and security engineers who need a practical design they can evaluate independently.

AI adds most value when intent is incomplete and evidence is scattered. Rules remain preferable for exact syntax, signatures, permissions and timers. Machine learning can combine weak traffic signals; time-series models can learn workload-specific baselines; language models can interpret tickets and documentation, correlate evidence and propose a distinguishing next test. A conversational console does not establish reliability.

Work Deterministic baseline Potential AI improvement and prerequisite
Configuration Types, addresses, TTL and conflict checks Translate intent and cross-service dependencies, given authoritative inventory and documentation
Security Known indicators and explicit policies Rank unfamiliar behavior from combined signals, given representative data and labels
Inspection Repeatable checks Group findings by owner and business impact, given a trustworthy asset graph
Observability Measurements and thresholds Connect changes, logs and perspectives into testable hypotheses, given provenance and timestamps

An AI layer must outperform existing automation under comparable permissions, cost and risk. It should not receive credit for benefits that came from installing monitoring for the first time.

2. DNS foundations: correct records are not sufficient

A client normally asks a recursive resolver. The resolver uses cache or follows delegations through the root, TLD and authoritative servers. The registrar commonly controls parent delegation and DS, while the hosting provider controls child-zone records. A correct A record in the provider dashboard does not prove that clients can reach it.[S1]

A zone is a delegated administrative namespace. An RRset groups records with the same owner, class and type. A/AAAA supply addresses; CNAME supplies an alias; MX routes mail; TXT carries verification or policies; NS and SOA describe authority. An ordinary CNAME owner cannot also carry arbitrary A/MX data; DNSSEC has specified exceptions. Since an apex needs SOA/NS, a standard apex CNAME is not a universal solution. ALIAS/ANAME/flattening are provider features.[S2]

TTL is a cache constraint, not a global propagation stopwatch. Negative responses are cached too. RFC 2308 derives the authoritative negative-response lifetime from the lesser of SOA TTL and SOA.MINIMUM. Resolver policy, application caches and prefetch affect observations. With serve-stale, some resolvers may serve expired data when refresh fails.[S3][S4]

DNSSEC authenticates DNS data and integrity, not query confidentiality or application safety. DoT and DoH protect their respective transport connections; they do not replace DNSSEC or conceal queries from the chosen resolver. Parent DS and child DNSKEY/RRSIG inconsistencies can cause validating resolvers to return SERVFAIL even when direct authoritative queries answer.[S5][S6][S7]

3. A running scenario: launch a new API

The team requests “move the API to the new ingress.” Use reserved example.com and documentation addresses 192.0.2.10 and 192.0.2.20; these are not deployable targets. This is an original teaching scenario, not an audit of tokenlab.fyi.

Before proposing changes, identify the exact owner name, environment, current and target RRsets, IPv6 readiness, proxy/CDN behavior, certificate coverage, window, rollback conditions and shared mail or verification dependencies. Missing targets or ownership must produce missing-information fields, not invented records.

Create an evidence package containing ticket ID, read-only zone snapshot and version, asset ID, allowed names, provider documentation version, recent changes and probes. The output is a minimal structured diff with reasons, dependencies, acceptance checks and a rollback snapshot. Store its machine-readable plan separately from its explanation.

Original reference design: AI proposes; independent checks authorize changes. DNS resolution stays outside the LLM path.
Original reference design: AI proposes; independent checks authorize changes. DNS resolution stays outside the LLM path. Open full-size diagram

4. Configuration: translate intent, then enforce independently

A mail-onboarding ticket can imply MX, SPF, DKIM, DMARC and verification TXT changes across several providers. A language model can reconcile their documentation and existing senders, suggesting a merged SPF policy instead of adding another independent SPF policy. That reduces interpretation work. SPF lookup constraints, MX targets, DKIM selectors and DMARC alignment still require dedicated checks. A TXT record's existence alone does not demonstrate authenticated email success.[S8][S9]

Use six stages: read live state; propose the smallest diff; check schema, scope and protocol/provider constraints; preview provider changes; authorize and apply; verify from authority and representative recursive perspectives. DNSControl separates preview from push; octoDNS provides declarative cross-provider management. These tools already offer valuable automation. AI helps produce, explain and review the plan.[S10][S11]

Bind approval to plan hash and expected configuration version. Re-read before applying and reject stale plans. Atomic conditional updates require provider support; otherwise use a controlled writer, locks and replanning to reduce the race window. A read alone is not atomic protection. On timeout, inspect change ID and actual state before retrying. Multi-provider changes are generally not one transaction: define partial-failure and compensation behavior.

Check suffix mistakes, trailing dots, uniform RRset TTL, TXT string segmentation, wildcard/delegation boundaries, private addresses in public zones, premature AAAA, CAA, and sensitive NS/DS changes. Explain failures with AI; enforce rejection outside the model.

TTL planning needs cache history

At 12:00, lower an existing TTL from 3600 to 300 seconds. A resolver that cached the old value at 11:59:59 may normally retain it until nearly 13:00. Cutting over at 12:05 cannot retroactively shorten that entry. Wait the previous cache window before switching and keep the old endpoint usable for an appropriate overlap. Application caches and long-lived connections need separate treatment.

AI can propose TTL choices from release windows, query load and recovery objectives. Lower TTL increases upstream work; higher TTL extends old-answer exposure. “300 seconds” does not promise worldwide completion in five minutes. Rollback publishes another state; it cannot recall answers already cached.[S3][S4]

As checked for this article, May 2026 RFC 9989 supersedes RFC 7489/9091 for DMARC. Check current policy-discovery requirements and receiver support rather than copying historical templates.[S9]

5. Security: combine behavior instead of guessing from strings

Separate protection of DNS infrastructure from detection of endpoint abuse through DNS. Infrastructure protection concerns availability, amplification, access, rate and capacity. Endpoint security concerns phishing, command-and-control, DGA and tunneling. Their observation points and responses differ.

ML can combine label length, character distribution, unique-subdomain ratio, NXDOMAIN rate, periodicity, query types, domain age, passive-DNS relationships and endpoint identity. None alone proves abuse. CDNs, telemetry and software updates also generate long random-looking names. Environment-aware models may improve ranking over a single entropy threshold, but that benefit must be demonstrated locally. Cloudflare has publicly described ML for DGA and tunneling detection; this establishes an application of the method, not universal superiority.[S12]

A language model can connect suspicious queries with EDR process evidence and summarize what remains unknown. It should not convert a fluent suspicion into a company-wide shared-CDN block. Start with monitoring or a narrowly scoped response; require corroboration, expiry, exceptions and reversal for blocks.

Visibility limits detection. UDP/53 logs miss queries sent through external DoH. Obtain authorized endpoint/resolver visibility and declare gaps. Encrypted-flow classification does not recover exact query content by magic. Authoritative servers often see recursive resolvers, not individual users, and do not see recursive cache hits.[S6][S7]

6. Why a seemingly accurate detector can overwhelm analysts

Consider one million endpoint–domain windows daily, with a malicious prevalence of 0.01%: 100 malicious windows. At 95% recall and a 0.1% benign false-positive rate, there are 95 true positives, 5 false negatives and about 1000 false positives among 999900 benign windows. Alert precision is only about 8.7%. This is original arithmetic using synthetic assumptions, not a vendor benchmark.

Here p is malicious prevalence, r recall and f benign false-positive rate, all fractions. Precision is the fraction of alerts that are truly malicious. With , and , precision is approximately 0.086766.

Synthetic low-base-rate example: 95 true alerts, about 1000 false alerts; precision is only 8.7%.
Synthetic low-base-rate example: 95 true alerts, about 1000 false alerts; precision is only 8.7%. Open full-size diagram

Measure confirmed incidents per analyst-hour, false alerts per thousand endpoints, delay, business damage from blocks and performance by workload. Split evaluation by time and related domains/organizations to avoid near-duplicate or family leakage. Watch distribution drift after deployments, and expire exceptions.

A score is not automatically a calibrated maliciousness probability. Choose thresholds using false-block and missed-attack costs. Compare in shadow mode before granting action scope. Evidence and authorization justify a consequential action; a model saying “0.98 confidence” does not.

7. Inspection: collect predictably, prioritize intelligently

Deterministic inspection should examine parent/child NS and reachability, necessary glue, authoritative convergence appropriate to the provider, DNSSEC chain and signature expiry, UDP/TCP and IPv4/IPv6, TTL and negative caching, CNAME chains/loops, orphan records, CAA/mail posture and public/private views.[S13][S14]

Expected differences matter. GeoDNS and split-horizon can legitimately return different answers. A shared SOA serial alone does not prove complete control-plane equivalence; managed services may not expose traditional transfer workflows. Record intended view behavior before evaluating consistency.

AI can group a thousand stale aliases into one retired supplier incident, connect a small finding to a critical payment service, resolve ownership and propose repair order. The improvement comes from asset and dependency context, not a prettier description. Without those relationships, impact ranking is speculative.

A dangling CNAME target returning NXDOMAIN or HTTP 404 is a lead, not proof of takeover. Confirm provider claim rules, resource existence and ownership without attempting to claim someone else's resource. Deletion still needs dependency evidence and a recoverable snapshot.

8. Observability: preserve the perspective of every measurement

Distinguish client/system cache, recursive resolver, authority and application/TLS. Low authoritative latency does not prove successful client resolution; a fast recursive response might be NXDOMAIN.

Layer Evidence Limitation
Client / synthetic probe Name/type, resolver, view, RCODE, expected RRset, duration, timestamp Represents that perspective, not every user
Recursive resolver Cache hit/miss, upstream errors, validation, timeout, load Misses traffic routed elsewhere
Authority Query/response rates, network/region, TCP fallback, capacity Does not count all endpoint queries
Change and application Versioned diff, approval, rollout, TLS/HTTP symptoms Temporal correlation alone is not causality

CoreDNS exports request counts, response codes and processing durations through its Prometheus plugin; other plugins add metrics. Confirm version, labels and measurement boundary. Do not treat service processing time as end-to-end resolution latency. Keep high-cardinality QNAME/client identifiers out of metric labels; use access-controlled logs with sampling and retention.[S15]

Time-series models can learn per-workload and seasonal baselines. LLMs can produce bounded queries, align timelines and propose discriminating probes. Anomaly detection locates deviation; evidence-based investigation assesses explanations. Neither replaces the measurement.

9. Incident: some users receive NXDOMAIN after creation

At 12:00 a prerelease client queries the not-yet-created API name. Assume a 900-second negative TTL. At 12:02 authority publishes the new A record. At 12:03 both authoritative servers answer correctly; public resolver A succeeds; enterprise resolver B still returns NXDOMAIN with about 720 seconds remaining, all other assumptions unchanged.

Compare negative cache, delegation error, DNSSEC failure, intentional private-view difference and resolver-network failure. Ask for direct authoritative responses, the affected resolver's decreasing negative TTL, creation time, view, validation and Extended DNS Errors. EDE can add context but is not universally available or independently trustworthy.[S16]

Synthetic incident: compare authoritative and recursive views before choosing a new probe. This supports a hypothesis, not a proven root cause.
Synthetic incident: compare authoritative and recursive views before choosing a new probe. This supports a hypothesis, not a proven root cause. Open full-size diagram

Here the timeline and declining TTL support negative caching. Reprobe after the predicted window; authorized operators may selectively clear caches they control. Keep correct authority stable. If failure persists or authority differs, reject the hypothesis. AI helps by choosing the next useful question, not by declaring a cause from one symptom.

If validators instead return SERVFAIL while authority answers, inspect DS/DNSKEY/RRSIG, signature time, clocks and packet/TCP behavior. Do not delete DS or disable production validation as a generic repair. A diagnostic bypass belongs in an isolated testing perspective.

10. Kubernetes and multi-cloud context

Kubernetes DNS latency may involve search suffixes/ndots, CoreDNS saturation, forwarding, NodeLocal DNSCache, conntrack, packet loss or upstream authority. Short application names can trigger multiple queries. A healthy CoreDNS process does not establish node-to-DNS connectivity.[S17]

AI can connect Pod DNSPolicy, resolv.conf, node placement, deployment changes and resolver metrics to test “only these nodes” or “only cache misses.” That is useful cross-object reasoning only when evidence belongs to the same incident window and workload mapping. A single error log is insufficient.

In multi-cloud, retain account, project, region, VPC/network and view for private-zone associations, forwarding and private endpoints. Do not merge identical internal and public names. Inject authorization scope into tools from authenticated context instead of allowing the model to choose arbitrary accounts.

11. Architecture and trust boundaries

Use deterministic collectors, an evidence store, rule/statistical/ML detectors, a retrieval-and-tool LLM, and an independent policy/approval/execution plane. Each evidence item needs ID, timestamp, source, view, query parameters, raw result and configuration version. Preserve the proposed hypothesis separately from observations.

Constrain tool schemas, name scope, rate, timeouts and response sizes. DNS TXT, pages, logs and tickets are untrusted content: an embedded instruction to delete a zone is data, not authority. Keep long-lived write credentials outside the model; enforce identity, policy, plan hash and expiry. Audit model and documentation versions, evidence references and outcomes.

Keep heavy LLM investigation off the resolution hot path. If it fails, DNS, ordinary alerts and human runbooks must continue. Open read-only collection first; generate drafts next; grant narrow actions only after evaluation. Sensitive NS/DS, bulk deletion and global security policy require stricter authorization and verification.

12. Tools and commercial systems

Layer Tools to consider Why and boundary
Declarative changes DNSControl / octoDNS Reuse providers and reviewable diffs; AI proposes rather than replacing execution [S10][S11]
Queries and validation dig / dnspython / DNSViz Obtain real responses and DNSSEC-chain evidence [S14][S18]
Cluster discovery CoreDNS Mature plugin and metric mechanisms; AI assists diagnosis [S15][S17]
Telemetry Prometheus / Grafana / existing log platform Build queryable evidence before a natural-language interface
Commercial protection Cloudflare / Infoblox Compare coverage, deployment point, false positives and response controls [S12][S19]

Cloudflare documents both traffic-baseline Advanced DNS Protection and ML for DGA/tunneling; these are different tasks, not one autonomous DNS manager. Infoblox describes DNS threat intelligence, streaming analytics and ML. Confirm current scope and contractual deployment details. These are vendor-documented capabilities, not an independently measured ranking.[S12][S19][S20]

For an existing GitOps team, start with a read-only investigator and configuration PR drafts checked independently. For security, start with shadow detection and analyst ranking. A small stable zone may already be well served by IaC and ordinary monitoring.

13. Prove the improvement and account for cost

Compare manual/current process, rules plus automation, and the same tools plus AI. Replay matched incidents and synthetic faults. Measure diagnosis-time distribution, correct localization, evidence accuracy, unnecessary changes, false blocks, review time and inference cost. Rejected bad suggestions still count as model failures.

Define an SLO around correct, timely answers for specified expected names and user perspectives. NOERROR can carry no requested data; NXDOMAIN can be correct for an intentionally absent probe. Keep synthetic-resolution and real-application denominators separate. Ten million eligible monthly probes at 99.99% allow 1000 failed probes, not 1000 minutes or an automatic business-request budget.

Original cost example: 200 monthly investigations saving eight minutes at $60/hour yield $1600 gross labor savings. Subtract $300 inference/retrieval, $600 maintenance and $200 extra review: $500 net. An added $3000 expected incident loss reverses the result. Better means faster decisions at acceptable total risk and cost, not more generated prose.

Roll out inventory/versioned evidence first, read-only assistance second, reviewable diffs third, and bounded action only after shadow evaluation. Research opportunities include low-base-rate detection, calibration, cross-environment transfer, privacy-preserving learning, evidence-backed causal diagnosis and safe planning under caches and concurrency.

14. Local experiment, negative tests and transfer exercises

The standard-library Python 3.11+ fixture performs no network calls or DNS changes and needs no API key. It demonstrates a deliberately restricted A/CNAME gate, time-and-view-aware negative-cache investigation and the base-rate calculation. It tests deterministic guardrails, not LLM intelligence or a complete zone validator.

Download the Python fixture, then run it locally. No network or API key is used.

dns-evidence-gate.py
python3 dns-evidence-gate.py

Expected output

checks=25 clean=candidate stale_plan=rejected cache=negative_cache_candidate
synthetic_tp=95 fn=5 fp=999.9 precision=8.6766%
Python · dns-evidence-gate.py
"""Offline teaching fixture. No network, model calls, or production writes.
Python 3.11+. Only A/CNAME records, not a complete DNS validator.
"""
import copy
import hashlib
import ipaddress
import json
import math


def canonical_name(value):
    if not isinstance(value, str) or not value.endswith('.'):
        raise ValueError('absolute_name_required')
    name = value.lower()
    labels = name[:-1].split('.')
    if len(name.encode('ascii')) > 254 or any(
        not label or len(label) > 63 or
        any(c not in 'abcdefghijklmnopqrstuvwxyz0123456789-' for c in label) or
        label.startswith('-') or label.endswith('-') for label in labels
    ):
        raise ValueError('restricted_hostname_required')
    return name


def validate(records, zone='example.com.'):
    """Restricted hostname-only zone policy, deliberately rejects other types."""
    zone = canonical_name(zone)
    by_name = {}
    for record in records:
        if set(record) != {'name', 'type', 'ttl', 'value'}:
            raise ValueError('schema')
        name = canonical_name(record['name'])
        if name != zone and not name.endswith('.' + zone):
            raise ValueError('outside_zone')
        ttl = record['ttl']
        if type(ttl) is not int or not 30 <= ttl <= 86400:
            raise ValueError('ttl_policy')
        kind, value = record['type'], record['value']
        if kind == 'A':
            if ipaddress.ip_address(value).version != 4:
                raise ValueError('ipv4_required')
        elif kind == 'CNAME':
            canonical_name(value)
            if name == zone:
                raise ValueError('apex_cname')
        else:
            raise ValueError('unsupported_type')
        by_name.setdefault(name, []).append(record)
    for rr in by_name.values():
        if any(r['type'] == 'CNAME' for r in rr) and len(rr) != 1:
            raise ValueError('cname_conflict')
        if len({r['ttl'] for r in rr}) != 1:
            raise ValueError('rrset_ttl')
    return 'candidate'


def plan_hash(records):
    return hashlib.sha256(json.dumps(records, sort_keys=True,
                                     separators=(',', ':')).encode()).hexdigest()


def apply_gate(records, approved_hash, expected_version, actual_version):
    # Illustrates checks, not an atomic provider write or a lock.
    if expected_version != actual_version:
        raise ValueError('stale_plan')
    if plan_hash(records) != approved_hash:
        raise ValueError('changed_plan')
    return validate(records)


def diagnose(authority, recursive, now):
    """Suggest a hypothesis and next test; never claims proven root cause."""
    required = {'name', 'type', 'view', 'at', 'rcode', 'answer', 'source'}
    if not authority or not required <= authority.keys() or not required <= recursive.keys():
        return 'investigate'
    if any(not 0 <= now - o['at'] <= 60 for o in (authority, recursive)):
        return 'investigate'
    if any(authority[k] != recursive[k] for k in ('name', 'type', 'view')):
        return 'investigate'
    ttl = recursive.get('negative_ttl')
    if (authority['source'] == 'authoritative' and
        recursive['source'] == 'recursive' and
        authority['rcode'] == 'NOERROR' and authority['answer'] and
        recursive['rcode'] == 'NXDOMAIN' and not recursive['answer'] and
        type(ttl) is int and ttl - (now - recursive['at']) > 0):
        return 'negative_cache_candidate'
    return 'investigate'


def run_checks():
    checks = 0
    def reject(fn):
        nonlocal checks
        try:
            fn()
        except (ValueError, UnicodeError):
            checks += 1
        else:
            raise AssertionError('unsafe candidate accepted')
    clean = [{'name': 'api.example.com.', 'type': 'A',
              'ttl': 300, 'value': '192.0.2.20'}]
    assert validate(clean) == 'candidate'
    checks += 1
    for patch in ({'value': 'not-an-ip'}, {'value': '2001:db8::1'},
                  {'name': 'api.otherexample.com.'}, {'ttl': True}, {'ttl': 0},
                  {'name': 'api.example.com'}, {'type': 'TXT'}, {'extra': 1}):
        bad = copy.deepcopy(clean)
        bad[0].update(patch)
        reject(lambda: validate(bad))
    alias = {'name': 'api.example.com.', 'type': 'CNAME',
             'ttl': 300, 'value': 'edge.example.net.'}
    reject(lambda: validate(clean + [alias]))
    reject(lambda: validate([dict(alias, name='example.com.')]))
    reject(lambda: validate(clean + [dict(clean[0], ttl=600, value='192.0.2.10')]))
    digest = plan_hash(clean)
    assert apply_gate(clean, digest, 'v1', 'v1') == 'candidate'
    checks += 1
    reject(lambda: apply_gate(clean, digest, 'v1', 'v2'))
    reject(lambda: apply_gate([dict(clean[0], ttl=600)], digest, 'v1', 'v1'))
    auth = {'name': 'api.example.com.', 'type': 'A', 'view': 'public',
            'at': 180, 'rcode': 'NOERROR', 'answer': ['192.0.2.20'],
            'source': 'authoritative'}
    rec = dict(auth, source='recursive', rcode='NXDOMAIN', answer=[], negative_ttl=720)
    assert diagnose(auth, rec, 180) == 'negative_cache_candidate'
    checks += 1
    for a, r, now in ((None, rec, 180), (auth, dict(rec, view='private'), 180),
                      (auth, rec, 241), (auth, dict(rec, negative_ttl=0), 180),
                      (auth, dict(rec, rcode='SERVFAIL'), 180),
                      (auth, dict(rec, type='AAAA'), 180),
                      (dict(auth, answer=[]), rec, 180),
                      (auth, dict(rec, at=200), 180)):
        assert diagnose(a, r, now) == 'investigate'
        checks += 1
    tp, fn, fp = 100 * .95, 100 * .05, 999900 * .001
    precision = tp / (tp + fp)
    assert math.isclose(precision, .086765914695406, rel_tol=1e-12)
    checks += 1
    print(f'checks={checks} clean=candidate stale_plan=rejected cache=negative_cache_candidate')
    print(f'synthetic_tp={tp:.0f} fn={fn:.0f} fp={fp:.1f} precision={precision:.4%}')


if __name__ == '__main__':
    run_checks()

Negative tests cover CNAME/A conflicts, invalid addresses, out-of-zone owners, invalid TTL, stale approved state, mismatched view, stale observations, exhausted negative TTL and missing authoritative evidence. Insufficient evidence yields investigate. No plausible model explanation can bypass rejection.

For real deployment, fill the same evidence fields through read-only adapters, preserve raw responses and limit probe rate/timeouts. Never wire this fixture's candidate result directly to production writes or treat provider API success as client acceptance.

Exercises: design new-name creation versus existing-name cutover with 3600-second old TTL and 900-second negative TTL; distinguish DNSSEC errors from network failures when authority answers but recursion fails; test false positives on benign CDN traffic with time/family separation; and introduce a concurrent change after approval to prove stale-plan rejection. Independent design, implementation, debugging and evaluation establish competence beyond reading.

Predict, test and keep evidence

Before revealing an answer, predict one result. After the exercise, record the discrepancy and a transfer test. Saved locally across language editions.

Open notebook / export / clear →

The mathematical review scope is recorded per lesson. It does not establish empirical paper reproduction; report suspected errors in your notes. Review scope

Primary sources and further reading

Sources checked November 16, 2026. Architectures and arithmetic are original teaching examples; product capabilities follow official documentation. No vendor benchmark or production DNS audit was performed.

  1. S1 · RFC 1034 — DNS conceptshttps://www.rfc-editor.org/rfc/rfc1034 · 2026-11-16
  2. S2 · RFC 2181 — DNS clarificationshttps://www.rfc-editor.org/rfc/rfc2181 · 2026-11-16
  3. S3 · RFC 2308 — Negative cachinghttps://www.rfc-editor.org/rfc/rfc2308 · 2026-11-16
  4. S4 · RFC 8767 — Serve stalehttps://www.rfc-editor.org/rfc/rfc8767 · 2026-11-16
  5. S5 · RFC 4033 — DNSSEC introductionhttps://www.rfc-editor.org/rfc/rfc4033 · 2026-11-16
  6. S6 · RFC 7858 — DNS over TLShttps://www.rfc-editor.org/rfc/rfc7858 · 2026-11-16
  7. S7 · RFC 8484 — DNS over HTTPShttps://www.rfc-editor.org/rfc/rfc8484 · 2026-11-16
  8. S8 · RFC 7208 — SPFhttps://www.rfc-editor.org/rfc/rfc7208 · 2026-11-16
  9. S9 · RFC 9989 — DMARC (May 2026; obsoletes RFC 7489/9091)https://www.rfc-editor.org/info/rfc9989/ · 2026-11-16
  10. S10 · DNSControl — preview/pushhttps://docs.dnscontrol.org/commands/preview-push · 2026-11-16
  11. S11 · octoDNS — official repositoryhttps://github.com/octodns/octodns · 2026-11-16
  12. S12 · Cloudflare — ML for malicious domainshttps://blog.cloudflare.com/threat-detection-machine-learning-models/ · 2026-11-16
  13. S13 · RFC 9471 — Glue requirementshttps://www.rfc-editor.org/rfc/rfc9471 · 2026-11-16
  14. S14 · DNSViz — DNSSEC visualizationhttps://dnsviz.net/ · 2026-11-16
  15. S15 · CoreDNS — Prometheus metricshttps://coredns.io/plugins/metrics/ · 2026-11-16
  16. S16 · RFC 8914 — Extended DNS Errorshttps://www.rfc-editor.org/rfc/rfc8914 · 2026-11-16
  17. S17 · Kubernetes — Debugging DNS resolutionhttps://kubernetes.io/docs/tasks/administer-cluster/dns-debugging-resolution/ · 2026-11-16
  18. S18 · dnspython — official documentationhttps://www.dnspython.org/ · 2026-11-16
  19. S19 · Infoblox — Threat Defensehttps://www.infoblox.com/products/threat-defense/ · 2026-11-16
  20. S20 · Cloudflare — Advanced DNS Protectionhttps://developers.cloudflare.com/ddos-protection/advanced-ddos-systems/overview/advanced-dns-protection/ · 2026-11-16

Related learning

RAG · Agent architecture