An 8-K is how a public company tells the market something material just happened — an acquisition, an executive departure, a preliminary earnings release. For a monitoring agent watching a portfolio, it's the highest-value filing there is: timely, event-driven, and often market-moving. Wiring an agent to watch for 8-Ks looks like a weekend project. At the scale of a real watchlist, three things turn it into an infrastructure problem.
TLDR:
- 8-K volume is high and continuous: 66,110 filed in 2025 — roughly 254 per business day — each due within four business days of the event.
- Polling EDGAR for a fleet runs into the 10 requests/second shared cap; the real work is classifying the event and deduping amendments, not fetching.
- A structured event feed moves parsing, classification, and citation upstream, so the agent reasons about events instead of scraping for them.
The workload is bigger than it looks
Start with cadence. Companies filed 66,110 8-Ks in 2025 — about 254 every business day — and each must be filed within four business days of the triggering event, so the flow is steady rather than batched.
Figure 1: 8-K cadence. Sources: SEC DERA; Investor.gov.
An 8-K isn't one thing, either — it's a container for many event types, each reported under a different item number:
| 8-K item | Event |
|---|---|
| 1.01 / 1.02 | Entry into / termination of a material agreement |
| 2.01 | Completion of an acquisition or disposition |
| 2.02 | Results of operations (preliminary earnings) |
| 5.02 | Departure or appointment of directors/officers |
| 7.01 / 8.01 | Regulation FD disclosure / other events |
Source: item categories per SEC Form 8-K.
A monitoring agent rarely wants "all 8-Ks." It wants "a 5.02 for anyone in my portfolio" or "a 2.02 before the call." That means classifying every filing by event type — the part that's actual work.
Where the naive pipeline breaks
EDGAR itself is fast: the submissions feed updates with a processing delay under a second. The trouble is everything downstream of the fetch.
| Failure point | Why it bites at fleet scale |
|---|---|
| Rate cap | The 10 req/s cap is per user, all machines combined — polling thousands of companies frequently competes against that single budget |
| Event classification | Raw 8-K HTML must be parsed into item types before it can be filtered; a summarizer that misreads an item is a missed or false alert |
| Amendments | Filers correct filings — 1,453 8-K/A in 2025 — so a monitor must dedupe an amendment against the original, not re-alert |
| Text fragility | Classifying by free-text is exactly the workload the evidence says is brittle: summarization flips decisions in 21–53% of cases |
Sources: SEC.gov; SEC DERA; arXiv:2606.29251.
None of these is about reaching the filing. They're about turning a raw document into a reliable, deduped, classified event — and doing it for every company on the list, continuously. That's the work that scales badly.
Figure 2: The naive pipeline runs on every watched company, every poll; a feed runs the hard part once, upstream.
What a monitoring stack actually needs
The build-or-buy line for monitoring is the same one from our scrape-vs-API breakdown, sharpened by the real-time requirement:
| Requirement | What it does |
|---|---|
| Low-latency change signal | Surfaces a new 8-K without spending the whole rate budget polling |
| Event classification by item type | Lets the agent filter on structured fields, not prose |
| Amendment resolution | Updates the event on a correction instead of firing a duplicate alert |
| Structured extraction with citations | Ties "CEO departed" to the exact 8-K, so the alert is auditable |
Requirements follow from the failure points above; EDGAR constraints per SEC.gov.
Get those upstream and the agent's job collapses to what it's good at: judgment on a clean, classified event. That's the shape FocusAlpha delivers — filings discovery, 8-K bodies and exhibits as documents, and semantic retrieval over them, every value cited back to the source. The monitoring loop stops being a scraper and becomes a reasoner.
FAQ
What is an 8-K filing?
An 8-K is a "current report" a public company files with the SEC to announce major events shareholders should know about — acquisitions, executive changes, preliminary earnings, material agreements, and other events, each reported under a specific item number.
How quickly must a company file an 8-K?
Generally within four business days of the event that triggers the filing requirement, so 8-Ks arrive in a steady stream — 66,110 of them in 2025.
How do AI agents monitor SEC 8-K filings?
By watching EDGAR's submissions feed (or a data provider's event feed) for new 8-Ks, classifying each by item type, deduping amendments, and extracting the material facts. The fetch is easy; the classification, dedup, and extraction are the real work.
What's the hard part of monitoring 8-Ks at scale?
Not fetching — EDGAR's feed updates in under a second — but doing the downstream work reliably for many companies at once under the 10 req/s shared cap, while classifying event types and not re-alerting on the 1,453 amendments filed in 2025.
Can I get real-time 8-K alerts directly from EDGAR?
EDGAR's submissions API is near real-time, but its fair-access policy caps you at 10 requests/second across all machines, which constrains how frequently a large watchlist can poll. A structured event feed removes that polling burden.
How do amendments affect 8-K monitoring?
Filers amend 8-Ks — 1,453 8-K/A in 2025 — so a monitor must recognize an amendment as an update to a prior event, not a new one, or it fires duplicate and possibly contradictory alerts.
Does FocusAlpha support 8-K monitoring?
Yes — the filings API surfaces new 8-Ks with item context, documents returns their bodies and exhibits as structured text, and retrieval searches across them, each value cited to the source so an alert is auditable.
What is FocusAlpha?
FocusAlpha is a SEC filings API and agent-ready financial data layer: it turns SEC filings (10-K, 10-Q, 8-K, 13F), earnings-call transcripts, and other trusted company communications into structured, normalized data where every value keeps its citation back to the source document. AI agents connect via API or MCP to research public companies from complete, trusted information.