Regulatory State, Not Filings: How We Maintain What's Actually True

Most systems that touch EDGAR answer the same question:

"Did a filing happen?"

That's the wrong question.

The question decision-makers—and increasingly, agents—actually need answered is:

"What is currently true, and did that truth change?"

That difference sounds subtle. It isn't.

Filings are events. State is truth.

A filing is an event:

• a document was published
• at a point in time
• with an accession number

State is what you believe about the world after you account for:

• which filing is authoritative
• whether it supersedes something else
• whether it's been amended
• whether something expected hasn't arrived

A system that only tracks filings tells you what happened. A system that maintains state tells you what's true.

Why filings alone break down

If you've worked with EDGAR long enough, you've seen this:

1. A 10-Q posts.
2. Everyone updates their numbers.
3. An amendment quietly follows.
4. Half the stack keeps using the old version.

Or:

1. An issuer misses an expected filing window.
2. Nobody notices because nothing "happened."
3. Decisions get made on stale disclosures.

From an event perspective, nothing looks wrong. From a state perspective, everything is wrong.

What we mean by "regulatory state"

When we talk about regulatory state, we're not being abstract.

For each issuer, we maintain a small, explicit state model:

• What is the latest 10-K?
• What is the latest 10-Q?
• Which 8-K events are currently in force?
• Has anything been amended after publication?
• Is the disclosure set current—or stale?

That's it.

No sentiment. No interpretation. No prediction.

Just a maintained view of what filings currently define reality.

State transitions, not alerts

The important thing isn't that something happened. It's that state changed.

Examples of transitions that matter:

• CURRENT → AMENDED_AFTER_PUBLICATION

• STALE → CURRENT

• LATEST_10Q_UPDATED

• EXPECTED_10K_MISSING

These transitions are deterministic. They're explainable. And they're exactly what agents and downstream systems can reason over safely.

An alert might say:

"New filing detected."

A state transition says:

"The authoritative regulatory position for this issuer has changed, and here's how."

Those are very different signals.

Why "materiality" comes later

People often ask:

"But is it material?"

That's a fair question—but it's not the first one.

Materiality is a classification layer on top of state, not a prerequisite for maintaining it.

You can't reliably decide what's material if you can't first answer:

• which filing is authoritative
• whether something superseded it
• whether your prior belief is now invalid

State is the foundation. Materiality is an overlay.

How we make this defensible

Maintaining state isn't enough. You need to be able to prove it.

That's why every state transition we deliver is accompanied by an Evidence Pack:

• source accession numbers
• publish and ingest timestamps
• predecessor pointers
• methodology version
• delivery logs

This lets you answer a hard question calmly:

"Why did you believe this was true at the time?"

Not with a screenshot. Not with a Slack message. With a reconstructible artifact.

What we guarantee (and what we don't)

We guarantee:

• coverage for the issuers you authorize
• timely detection and delivery of state transitions
• explicit methodology
• complete evidence for reconstruction

We do not guarantee:

• that filings won't be amended
• that disclosures are "correct"
• that outcomes won't be superseded

Markets evolve. Regulatory truth evolves.

Our job is to preserve a defensible timeline of belief, not to pretend the world is static.

Why this matters for agents

Agents don't need filings. They need authoritative state with confidence signals.

An agent can safely do this:

• act only when state is

  CURRENT

• escalate when

  AMENDED_AFTER_PUBLICATION

• pause when

  DEGRADED

An agent can't safely reason over:

• raw PDFs
• emails
• loosely defined alerts

State is what makes automation responsible.

The takeaway

If your system answers:

"Did a filing happen?"

You're collecting events.

If your system answers:

"What is currently true, and did it change?"

You're maintaining state.

That difference is the line between information and assurance.

It's also the foundation everything else builds on—materiality, analytics, agents, and eventually, opinions.