Build: SEC filings analyst

In one line. An analyst agent reads every incoming SEC 8-K as it lands, decides whether it discloses a material event, routes the flagged ones to a human, and auto-files the routine rest — with an audit trail for every move. You’ll build. The 8-K Filings 2026 Processing collection with an 8-field schema, a scheduled SEC Public Feed connector, the analyst agent Aurora with a materiality skill and a cross-period tool, and a lifecycle that flags material filings to review and auto-files clean ones. You’ll use. Collections & schema, Taxonomy, lifecycle, tags & events, Ingestion & connectors, Your first agent, Tools & functions, Skills & skill packs, Shaping the experience.

Public companies file 8-K reports whenever something material happens — a goodwill impairment, an executive departure, a legal settlement. They arrive as a stream, unevenly, all day. A human can’t read every filing of every issuer you care about fast enough to surface the ones that move the needle. This build is the platform’s own canonical demo: the collection is “8-K Filings 2026”, the analyst is “Aurora”, and the headline moment is “Aurora flagged a $1.2B goodwill impairment in Wells Fargo’s Q4 8-K.” Budget 50–70 minutes for the full build; about 20 if you skip the scheduled feed and upload a sample. Prerequisite: at least one LLM registered in the project (LLMs & services).

The shape: a scheduled Public Feed drips filings into a Processing collection; Aurora fills the schema on every arrival; a lifecycle branches on her materiality flags — material to a human, routine to auto-file.

Steps

Stage 1 — The collection and its schema

A Collection is the operational home for one type of record. Here the record type is “an 8-K filing.”

Go to Studio ▸ Data Model ▸ Collections. Click + Collection.
Purpose: leave Processing selected. This is the category that gives each document review stages, field extraction, and an agent that acts on each one — exactly what we want. It’s immutable after create, so pick deliberately.
Collection Name: 8-K Filings 2026. Description: Incoming SEC 8-K current-report filings, analysed for material events.
Leave the optional accordions at their defaults. Click Save. Select the new collection in the left rail — the detail pane shows its tabs: General · Schema · Lifecycle · Tags · Events · Ingestion · Agents. You’ll touch five of them in this build.

Schema drives extraction: the agent pulls a value for each Label you define, and only those. We define the issuer, the date, a classification of the event type, three materiality flags, and a confidence score — the confidence is what later decides whether a filing needs human eyes.

With 8-K Filings 2026 selected, open the Schema tab. Click Taxonomy (footer) to open Create Taxonomy: Taxonomy Name Filing Analysis, Description Top-level analysis of an 8-K filing, Type DocumentClassification (whole-document field extraction), Entity 8-K Filings 2026 (pre-filled). Click Submit.

Select Filing Analysis, then + Label. Add these, using Add between each and Add and exit on the last. Remember: a field’s shape comes from a validation rule in View Config, not a type dropdown.

Label	Description	Shape — how
`issuer`	`The filing company's name (e.g. "Wells Fargo & Co").`	Plain text (default)
`filing_date`	`The date the 8-K was filed.`	View Config → date validation
`event_type`	`The primary 8-K item/event category (e.g. impairment, exec change, settlement, other).`	View Config → validation listing allowed values (single-select)
`confidence`	`Aurora's confidence (0–1) that the event classification is correct.`	View Config → numeric validation

Add the three materiality flags — each is just a boolean Label, one per material-event family. Add three more Labels under Filing Analysis, each with a two-value (boolean) validation rule in View Config:

Label	Description
`is_impairment`	`True if the filing discloses a goodwill or asset impairment.`
`is_exec_change`	`True if the filing discloses an executive departure, appointment, or board change.`
`is_settlement`	`True if the filing discloses a legal settlement, judgment, or material litigation event.`

Keeping the three flags as separate booleans (rather than stuffing everything into event_type) pays off twice: the lifecycle can branch on “any flag true”, and your end-of-week View can filter on each event family independently. Checkpoint: the Labels tree under Filing Analysis shows 8 fields.

Stage 2 — Ingestion: a scheduled SEC Public Feed (or upload a sample)

The connector model is Connector = identity, Job = scope + schedule, Run = one execution (Ingestion & connectors). The SEC stream is a built-in Public Feed connector.

Flag-gated screen. This uses Sources v3 (Studio ▸ Connector ▸ Ingestion, flag ingestionV3). If you land on the older single-source wizard, enable ingestionV3 from the Lab menu first (Getting oriented).

Studio ▸ Connector ▸ Ingestion → + Connector.
Step 1 — kind: pick the Public Feed tile (“Public gov data (SEC, CFPB, Federal Register)”). Public Feed is a 2-step wizard — there’s no auth step.
Step 2 — pick the feed: in the registry, search for and select the SEC filings tile. Live tiles are selectable with a primary border; greyed tiles are “Available in a future release” — don’t pick those. Each tile shows its name, description, drip behaviour, and a license/use-case chip.
Give the connector a name (defaults to the feed name), click Test connection — it reports the last item date, and Public Feed connectors cannot be saved until the test passes — then Save connector.
Back on the Ingestion screen → + Job. Step 1 — Connector: select your new SEC connector.
Step 2 — Scope & mapping: Job name 8-K nightly pull; the Public Feed renders its own scope fields (issuer/form filters where the feed exposes them); set Target collection to 8-K Filings 2026. Leave Secondary XFlows empty.
Step 3 — Schedule: public feeds offer preset chips — pick Every 6h (or Daily 9am UTC). Check the live Next 5 runs preview, then Create job.

A recurring feed job pulls only new items each run (drip) and reports Dup for filings it has already seen (dedup), so running every 6h is safe and cheap — you won’t reprocess yesterday’s filings.

Faster alternative — skip the connector entirely and upload a sample for the walkthrough:

Studio ▸ Connector ▸ Ingestion → Upload. Drag in a sample 8-K PDF (e.g. a real Wells Fargo Q4 8-K), set Target collection = 8-K Filings 2026, Submit. The result panel shows the registration and the run id; the document is now in the collection with a “Processing…” chip — perfect for testing the rest of the build immediately.

Checkpoint: either the Jobs tab shows 8-K nightly pull · Every 6h · active (click Run now to trigger it and watch the Runs funnel fill), or your uploaded sample is sitting in the collection. Filings are flowing in.

Stage 3 — Aurora, her skill, and her tool

This is the brain: a persona, a model, one skill, one tool, and a structured output that fills the schema. Full editor tour: Your first agent.

Studio ▸ Agent Builder ▸ Agents → + Agent ▸ Agent.

Persona tab. Name: Aurora. Description: Reads SEC 8-K filings and flags material events for analyst review. Instructions (the system prompt — the soul of the agent): click the co-pilot, seed it with “Analyse an SEC 8-K filing and flag any material events,” then refine the draft to read roughly:

You are Aurora, a senior SEC filings analyst. For each 8-K filing, identify the issuer, the
filing date, and the primary event it reports. Decide whether the filing discloses a material
event in any of these families: a goodwill or asset impairment, an executive or board
change, or a legal settlement / material litigation. Set the matching flag(s) to true and
classify event_type. Quote the exact sentence that supports each flag. If a filing is routine
and discloses nothing material, set all flags false. Never invent a fact the filing does not
state; report only what the document supports, and give your confidence in the classification.

Model tab. Pick your project’s LLM Model. Agent Mode = Thinking — materiality is a reasoning call, not a lookup; you’ll watch its reasoning while testing, then ship in Fast if you trust it. Leave Advanced sampling at defaults.
Output tab — this is what turns chatty Aurora into a data extractor. Turn on Structured output. Taxonomy/Learner: Filing Analysis. Process unit: Page. Confirm the Labels match your eight fields, each with its short Description. Turn on Reasoning, Confidence Score, and References — the confidence is what routes a filing to human review; references quote the supporting sentence, your audit evidence. Click Save Agent.
Now author the skill. A Skill captures a reusable instructions-plus-tools recipe once, so you can hand the same materiality playbook to other agents later (a CFPB analyst, a Federal-Register analyst) without rewriting the prompt. Studio ▸ Agent Builder ▸ Skills → Skills tab → + Skill.
Form tab: Name material-event-detector. Description (write this for discovery — when should an agent reach for it): “Decide whether an SEC filing discloses a material event (impairment, executive change, or legal settlement). Use when analysing an 8-K or similar current report.” Tags: sec, materiality.

Markdown tab — the body (write this for execution — how to do the job):

Read the filing. For each material-event family below, decide present/absent and quote the exact
supporting sentence:
1. Impairment — goodwill or asset write-downs, "impairment charge", non-cash impairment.
2. Executive / board change — resignation, appointment, departure of a named officer or director.
3. Settlement / litigation — settlement amount, judgment, consent decree, material legal proceeding.

Set the matching flag true only with a supporting quote. Classify event_type as the dominant
family (or "other"). State your confidence (0–1). If nothing material is disclosed, set all flags
false and event_type = routine.

Click Create (note the V1 chip). Then pin it onto Aurora: open Aurora → Capabilities tab → Skills → + Pin skill → material-event-detector → Save Agent. If you plan to add more SEC skills, bundle them into a Skill Pack (e.g. SEC-Analyst) — pin the pack once and every member skill comes with it (Skills & skill packs).
Now the tool — a callable Aurora can invoke mid-analysis: a custom API tool that fetches a prior-period filing for the same issuer so she can do a cross-period comparison (“is this impairment new, or already disclosed last quarter?”). Studio ▸ Agent Builder ▸ Tools → + Tool.
In the import grid, filter by type API Endpoint and import the closest GET-style card — the dialog flips to form view. Tool Name: filing-period-compare. Tool Description (the model reads this to decide whether to call it — say what and when): “Fetch a prior-period filing for the same issuer so the current filing can be compared. Use when you need to tell whether a disclosed event is newly reported or a continuation of a prior period.”

Code editor: point the API URL at your filings endpoint, method GET, and declare an input schema:

{
  "issuer":       { "type": "string", "description": "Issuer name or CIK" },
  "prior_period": { "type": "string", "description": "Period to compare against, e.g. 'previous-quarter'" }
}

If your endpoint needs a key, add a Default parameter value of type sensitive (masked) — never put credentials in the URL or description. Save. Then attach it: open Aurora → Capabilities → Tools → + Add tool → filing-period-compare → Save Agent.

Why a tool, not a skill? The skill is the materiality judgement (a prompt playbook); the tool is a single callable that fetches data the judgement needs. Verb (tool) vs playbook (skill) — see Skills & skill packs.

Checkpoint: select Aurora, open the right-pane Playground, set Input Type = Document, pick your sample 8-K, and press Enter. Watch the Thinking block, the eight extracted fields, the per-field confidence, the References back to the page — and a tool call to filing-period-compare in the transcript when she reaches for prior-period context. Flip Agent Mode = Fast and re-run — same fields, much quicker.

Stage 4 — Wire the loop: intake agent + lifecycle

An agent does nothing until it’s given a stream of work.

Go to 8-K Filings 2026 (Studio ▸ Data Model ▸ Collections) → open its Agents tab. Assign Aurora as the collection’s intake/processing agent. From now on, every filing that lands — pulled by the SEC job or uploaded — is run by Aurora automatically: she fills the eight schema fields and the document enters the lifecycle. The tab shows Aurora assigned, with an Open in Agent Builder link.
Now the life of a filing (Taxonomy, lifecycle, tags & events). Your collection was seeded with the 8-stage Four-Eyes flow (Intake → AI Processing → AI Recommendation → L1 Review → L2 Approval → Needs Info → Approved/Declined). We want: material filings go to a human; clean/routine filings file themselves. Open the collection’s Lifecycle tab.
Route material filings to L1 Review. On the AI Recommendation stage, add a Conditional automation that branches on the flags Aurora set: if is_impairment = true OR is_exec_change = true OR is_settlement = true → move to L1 Review (which has Send to Inbox = on, so it reaches a human); else → continue toward Approved. The Conditional type is the routing workhorse — it reads an extracted/classification label value and picks the next stage. That’s why we made the flags first-class booleans in Stage 1.

Auto-file the clean ones. Below the stage graph, open the Auto-Decide policy card and set:

Field	Value	Why
Enabled	`true`	Turn the policy on.
Applies To	`approve`	Auto-approve clean cases; always keep humans on anything flagged.
Min Confidence	`0.92` (default)	Only auto-file when Aurora is sure.
Require Zero Flags	`true` (default)	Any material flag open means no auto-file — it routes to L1.

The card’s plain-English preview should read roughly “Auto-approve when AI confidence ≥ 0.92 AND zero flags.” Save.

Watch out. Require Zero Flags = true is doing the heavy lifting here: a filing with any materiality flag set can never auto-file — it’s guaranteed to reach a reviewer. That’s the safety property you want.

Checkpoint: a routine 8-K with all flags false and confidence ≥ 0.92 skips both reviewers and lands in Approved. A filing where Aurora flags an impairment is routed to L1 Review and sent to the Inbox — every move written to the audit trail.

Stage 5 — Watch it live, then test end to end

Here’s the honest picture of which live views actually exist.

The consumer document list — real, works everywhere. Open the project’s consumer app → the 8-K Filings 2026 document list (Document workspace). When a filing is being processed, its row shows a live “Processing…” chip with a percentage that climbs in real time; when it reaches done, the extracted fields fill in and the status/score appears. This is real and not flag-gated — it works on QA and Prod.
The Agent OS “Living Workshop” heartbeat — real, but flag-gated. If you’re on a build with the agentOsDemo flag (realistically local/demo — it’s off in QA and Prod), open Agent OS ▸ Work ▸ 8-K Filings 2026. Because Aurora owns the collection, you get the Living Workshop: a heartbeat banner that breathes (Ready when idle, At work right now when a filing is in-flight); Now reading {filing} with a progress bar and the stage timeline (Loading → Validating → Parsing → Calling LLM → Extracting fields); a reasoning stream of Aurora’s live bullets (thoughts, extractions like “is_impairment = true”, flags) that fade in and decay; and this-shift pulse counters (done · extractions · flags · escalations). This is the canonical “Aurora flagged a $1.2B goodwill impairment in Wells Fargo’s Q4 8-K” moment.

Be honest about the boundaries. Agent OS Phase 1a is a read-only skin. The Home page’s “Currently running” and “What’s new” strips are always empty (telemetry not wired), Agent L2’s Recent runs / This week panels are stubs, and the only live heartbeat is the one inside Collection L2. If you’re on QA/Prod, use the consumer “Processing…” chip — it delivers the same “watch it happen” feeling without the flag.

Arrive. Upload a real Wells Fargo Q4 8-K (or Run now the SEC job). The document appears in the 8-K Filings 2026 list with a “Processing…” chip.
Read. The chip climbs as Aurora reads the filing. Fields fill in: issuer = Wells Fargo & Co, filing_date, event_type = impairment, is_impairment = true, confidence.
Flag and route. Because is_impairment = true, the Auto-Decide policy’s Require Zero Flags blocks auto-filing, and the Conditional on AI Recommendation routes the document to L1 Review. The filing lands in the Inbox (Dashboards & inbox) for a reviewer with the L1-Reviewer role. Open it — the References show the exact sentence Aurora quoted for the impairment.
Contrast. Upload a routine 8-K (no material event). All flags come back false, confidence is high — it auto-files to Approved without touching a human.
Audit. Open either document’s stage history — every move (AI handoff, route-to-L1 or auto-approve) is on the trail. The “decision” is that trail.

If a material filing doesn’t flag, sharpen the skill body or the field Descriptions on Aurora’s Output tab, re-run in the playground, repeat — that loop is the whole craft.

Make it production-worthy

Cross-period diff skill. Author a second skill period-over-period-diff that uses the filing-period-compare tool to report what changed since the prior filing (new impairment vs ongoing). Bundle it with material-event-detector into an SEC-Analyst Skill Pack and pin the pack onto Aurora (Skills & skill packs).
Alerts via a webhook Event. On the Events tab (D3), add an Event: trigger stage-change, scope Workflow = Four-Eyes · Stage = L1 Review, + Add Action → Webhook → your alerting endpoint. Now every flagged filing POSTs to your system the instant it’s routed — “material event detected, awaiting review.” Add Check SLA Breach if you want a late-review alarm too.
A “Material events this week” View and dashboard tile. In Studio ▸ Data Model, create a Project View named Material events (Shaping the experience): columns issuer · event_type · filing_date · confidence; filter any flag = true; Allowed roles = Analyst. Then in Studio ▸ Intelligence, add a View Widget pointed at that View (or a Query Widget counting flagged filings per week) — a live tile your analysts read in the dashboards. Add a Default Question in Studio ▸ Chat like “What material events were filed this week?” so chat opens on the question your users actually ask.

Where to go next

Build: Package & ship — package this whole build (collection, Aurora, skill, tool, lifecycle, View, dashboard) as a publishable Solution another project installs in one click (Hubs & solutions).
Taxonomy, lifecycle, tags & events — the Conditional automations and Auto-Decide policy in full.
Shaping the experience — Views, dashboard tiles, and chat starters: the bridge from builder to end-user.