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, writes its findings and the sentence that proves each one onto the filing, and hands every filing to an analyst with the material ones already flagged — with an audit trail for every move. You’ll build. The 8-K Filings 2026 Processing collection with a 7-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 brings every analysed filing to an analyst at L1 Review, material ones flagged. 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. The worked example on this page: the collection is “8-K Filings 2026”, the analyst is “Aurora”, and the moment you are building towards is “Aurora flagged a $1.2B goodwill impairment in a bank’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 language model 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, Auto-annotate writes her answer onto the filing and hands it to the lifecycle, which brings it to an analyst with her flags and her evidence already on it. The analyst still sees every filing — but sees it pre-read, with the material ones separable from the routine at a glance. That, not fewer filings, is the time this build buys back.

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 ▸ 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 list on the left — the detail pane shows its tabs: General · Taxonomy · 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, three materiality flags, and Aurora’s own overall confidence and call — the two an analyst reads to see how sure she was. Note what those last two are not: the platform’s auto-approve gate reads a plain recommendation and confidence stated at the top level of an agent’s reply, not a Label value. Stage 4 says what routing that leaves this build with; the recipe that does feed the gate is Build: Invoice settlement’s.

Watch out — three Label names are reserved, whatever case you use. Name a Label exactly recommendation, confidence or reason and the platform lifts its value out of the write-back and hands it to the gate instead of writing it onto the document. The field then reads empty on every document, and the gate acts on a value you meant for a person. That is why the two below are analyst_confidence and analyst_call. Use those three names only when you deliberately mean to feed the gate.

With 8-K Filings 2026 selected, open the Taxonomy tab. Click Taxonomy (footer) to open Create Taxonomy: Taxonomy Name Filing Analysis, Description Top-level analysis of an 8-K filing, Type Section Classification — this taxonomy pulls several values per filing, which is an extraction job, not a single whole-document category (that’s a different Learner type — see the watch-out below). 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
`analyst_confidence`	`Aurora's overall confidence (0–1) in this filing's analysis.`	View Config → numeric validation
`analyst_call`	`approve = routine, nothing material, confident; decline / needs-info = anything with a material flag or that you can't resolve.`	View Config → single-select validation listing `approve`, `decline`, `needs-info`

Watch out — Document Classification would make Aurora a single-label classifier. A Document Classification (or Page Classification) taxonomy’s labels are categories — the agent marks a filing with exactly one of them, the way the Triage taxonomy works in Build: Support intake triage. That’s wrong for this schema, which pulls several independent values per filing. Section Classification is the extraction type; keep document/event categorisation, if you want one, in its own taxonomy, as the production note below does.

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 pays off twice: an analyst opening a filing sees at a glance which family it belongs to, and your end-of-week View can filter on each family independently. Checkpoint: the Labels tree under Filing Analysis shows seven 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. Where: Studio ▸ Data ▸ Ingestion.

Studio ▸ Data ▸ 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 ▸ Data ▸ Ingestion → Upload. Drag in a sample 8-K PDF — any real filing works, and one that discloses an impairment exercises the whole loop — 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 ▸ Agents ▸ Agent Toolkit ▸ 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 and the
filing date. 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 quote the exact sentence that supports each
one. 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. Finally, give an overall
confidence (0–1) and a call: approve for a routine filing you're confident in, decline for one
with a confirmed material event, needs-info for anything you genuinely can't resolve from the
filing alone. Never say approve for a filing with any flag set true. Write both into the
analyst_confidence and analyst_call fields.

Those last two are for the person who opens the filing. They are fields on the document, not instructions the lifecycle acts on — Stage 4 shows what does the routing.

Model tab. Pick your project’s language 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 seven fields, each with its short Description. Turn on Reasoning, Confidence score, and References — references quote the supporting sentence, your audit evidence. Now turn on Auto-annotate document as well. They are two independent toggles doing two different jobs: Structured output shapes what Aurora answers, Auto-annotate is what writes that answer back onto the filing and hands the filing to the lifecycle. Leave Auto-annotate off and her answer never reaches the filing — its seven fields stay empty and it never leaves its first stage. With it on, every filing gets its values and reaches L1 Review (Stage 4). 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 ▸ Agents ▸ Agent Toolkit ▸ 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. State your overall confidence (0–1)
and your call. If nothing material is disclosed, set all flags false and call it approve.

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 — Skill Pack names are kebab-case only, like Skill names) — 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 ▸ Agents ▸ Agent Toolkit ▸ 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 seven 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. Watch out — with Auto-annotate on this is not a side-effect-free preview: the run writes the seven values onto that real filing and can move it through the lifecycle, the same as a live arrival. Pick a filing you don’t mind moving.

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 ▸ 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 seven schema fields and the document enters the lifecycle. The tab shows Aurora assigned, with a link that opens her in the agent editor.
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 every analysed filing in front of an analyst, with the material ones already marked. Open the collection’s Lifecycle tab.
Every filing goes to L1 Review — confirm the stage is wired for it. Auto-annotate routes each filing as it writes Aurora’s answer on, and with no plain top-level recommendation in her reply the platform has nothing to weigh, so it takes the collection’s normal path: L1 Review. Click the L1 Review stage to open the State editor and confirm Send to Inbox (human review) is on; do the same for L2 Approval. In the seeded flow they already are — you’re verifying, not adding. This is the routing for a flagged filing and a routine one alike.
Watch out — don’t put the routing in a Conditional here. A Conditional automation branches a document when it reaches the stage the automation sits on. This routing doesn’t walk the stage graph: it is a direct move to L1 Review by name, so an automation you add on a stage in between is not what decides where a filing goes, and may not get the chance to run at all. See for yourself on any filing’s ⋮ ▸ Audit trail, which lists the stages it actually visited. There is nothing for this build to branch on anyway — every filing has the same destination — and the three flag Labels earn their keep elsewhere: on the filing an analyst opens, and in the Material events View in Make it production-worthy.
Auto-decide policy card — leave it off (Auto-decide is OFF). Below the stage graph is the platform’s gate for auto-approving clean documents. It reads a plain top-level recommendation and confidence from the agent’s reply; Aurora reports hers as the analyst_call and analyst_confidence Labels, which the gate does not read, so enabling it would change nothing here. Make it production-worthy below covers the swap to the recipe that does feed it, and what you give up for it.

Checkpoint: upload a routine 8-K and one that discloses an impairment. Both land in L1 Review and both appear in the Inbox — the difference is on the filing, not in its route: the impairment one carries is_impairment = true and Aurora’s quoted sentence. Every move is written to the audit trail. If an item isn’t in the Inbox yet, refresh it: for a filing moved automatically, the item is added when the Inbox list loads, or by a background pass within about five minutes.

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

The consumer document list — where you watch it happen. 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. Keep this list open while you run the test below.
Arrive. Upload an 8-K that discloses an impairment (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, filing_date, is_impairment = true, analyst_confidence, analyst_call = decline (or needs-info). This is the “Aurora flagged a $1.2B goodwill impairment in a bank’s Q4 8-K” moment.
Route. The filing reaches L1 Review — as every filing in this build does — and so the Inbox (Dashboards & inbox), for whoever holds the L1-Reviewer persona; personas are defined on Studio ▸ Governance ▸ Users & Access ▸ Personas (Access & roles). Open the L1 Review item: is_impairment = true is on the filing, and the References show the exact sentence Aurora quoted for it. The flag is what makes this filing findable among the day’s routine ones — it is not what moved it.
Contrast. Upload a routine 8-K (no material event). All three flags come back false and analyst_call = approve — and it lands in L1 Review too, beside the flagged one. Nothing in this build auto-approves; that is step 32’s design. What the flags buy you is telling the two apart at a glance, and filtering one out of the other.
Audit. Every move — the AI hand-off, the route to L1, each human advance — is on the trail, and the “decision” is that trail. Read the whole trail on Studio ▸ Governance ▸ Oversight ▸ Audit & Usage, or open one filing’s own story from its row’s ⋮ ▸ Audit trail (Audit & compliance).

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 a 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 review — 8-K Filings 2026 · Stage = L2 Approval, + Add Action → Webhook → your alerting endpoint. It fires when an analyst moves a filing on from L1 Review — a move a person makes. The automatic hand-off into L1 Review doesn’t raise a stage-change Event, so an Event scoped to L1 Review stays silent for new filings. In the Webhook action’s Message, pick Placeholders ▸ Document Summary. That puts <<documentsummary>> in the Message, and the POST sends the filing’s summary JSON in its place: each extracted field by name with its values, the three flags among them. The POST carries what that Message holds and nothing else (an empty Message posts {}), and your alerting side reads is_impairment, is_exec_change and is_settlement from that JSON to decide which filings are worth waking someone for. The menu has no entry for a single field. If your project uses its own word for Document, the entry shows that word (say Filing Summary) and inserts <<filingsummary>>, which the POST does not fill in: change it to <<documentsummary>> by hand. Test webhook sends placeholders as written, so check the JSON on a real move to L2 Approval. Add Check SLA Breach if you want a late-review alarm too.
A trained event-type classifier (optional). The three booleans already tell an analyst what they need; if you also want a single trainable category per filing (for Studio ▸ Agents ▸ Classic ML, say), build it the way Build: Support intake triage builds Triage: a second taxonomy, Type: Document Classification, whose Labels — Impairment, Executive Change, Settlement, Routine — ARE the categories, filled by a second, dedicated classifier agent. An agent’s Output tab wires to one Learner at a time, so this is a second agent, not a second job for Aurora.
Auto-approve the routine ones — a different output recipe. To let clean filings skip the analyst, the gate has to see a verdict, and that means swapping Aurora’s Output tab to the other recipe: Structured output off, Auto-annotate on, and one flat JSON reply — a key per field plus a plain top-level recommendation and confidence — exactly as Build: Invoice settlement sets it up. Then switch the Auto-decide policy card to Auto-decide is ON, set Applies to = Approve only (recommended start) and a Min confidence. Two things to know first. Per-field Confidence score and References are a Structured-output-only display, so the swap costs you the quoted-sentence evidence this build rests on — on a filings desk that is usually worth more than the saved clicks, which is why this page keeps it. And Require zero open flags is on by default and applies here too: one value on the filing still marked as a problem and not cleared — a mark someone raised on it, a quality check it failed, a validation rule it broke — holds the filing for a person however confident Aurora was. That is a different thing from Aurora’s three materiality flags, which the card never looks at. Confirm the swap on one filing before you trust it: upload a routine 8-K, check it reaches Approved with no reviewer, and read its ⋮ ▸ Audit trail for the automatic accept.
A “Material events this week” View and a page that shows it. A View isn’t built on Studio ▸ Data ▸ Views — that page only lists, inspects and deletes. Open the 8-K Filings 2026 Documents surface, set columns issuer · filing_date · analyst_confidence · analyst_call and a filter on any flag = true, then Options ▸ Save View as, naming it Material events (Save Under = Project Views — Shaping the experience). That View is what your analysts pick from the Documents surface’s tab row. For the same picture on a page, Studio ▸ Experience ▸ Designer ▸ Pages gives you no “point at a View” setting on a card — place a DocList card and set its own Label columns (issuer · filing_date · analyst_confidence · analyst_call — the fixed Columns list doesn’t carry Label values, only built-ins like title/stage/updated) and Label filter to match (any flag = true), or a chart card counting flagged filings per week — a live tile your analysts read. Add a Default Question on Studio ▸ Experience ▸ Channels ▸ Chat like “What material events were filed this week?” so chat opens on the question your users actually ask.

Where to go next

Package & ship a solution — package this whole build (collection, Aurora, skill, tool, lifecycle, View, pages) 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, pages, and chat starters: the bridge from builder to end-user.