company-at-a-glance

name

company-at-a-glance

description

Produce a rigorous, fully-sourced data snapshot of a single company - a detailed multi-year financial table (revenue, gross profit, EBITDA, EBIT, net income per year), computed margins and growth with every derived figure footnoted to its formula and inputs, plus web-sourced profile facts (founded, CEO, ownership, employees, listing). Use whenever the user wants a company "at a glance", a snapshot / fact sheet / profile, "pull the financials for X", "what do we know about X", "give me the numbers on X", or names a single company to size up - even if they don't say "at a glance". Financials come ONLY from the Economic Mind financials connector and are flagged reported-vs-not-reported; profile facts are web-searched from credible sources and individually cited. The deliverable is data (Markdown + JSON); presentation is left to the client.

Company at a glance

Produce a one-page, fully-sourced snapshot of a single company. The deliverable is data - a Markdown report plus a JSON sidecar - not a styled document; how it is laid out is the client's job. The entire value is trust: every number is either reported (with its provider named) or shown as n/a, every derived figure carries a footnote with its formula and the exact inputs, and every profile fact is attributed to the source it came from. A reader should be able to audit any figure in the snapshot back to its origin without taking anything on faith.

Data sources (no exceptions)

There are two source channels, and they are never mixed. Keeping them separate is what lets a reader trust the numbers: the financials stay pristine and machine-traceable; the qualitative colour is clearly labelled as such.

1. Financials & figures - ONLY the Economic Mind connector. Every revenue, profit, margin and growth figure must trace to a get_company_financials call. Do not pull a financial number from the web, from memory, from a market report, or from a "sanity check" - even if the connector is slow, returns nothing, or seems wrong. If Economic Mind does not report a figure, it is n/a. There is no fallback.
2. Profile facts - web search, credible sources only. Founded, CEO, ownership, employees, listing status and a short "about" are qualitative context. Web-search them (see Phase 3), cite each one individually, and never let a web-sourced fact enter a calculation. If you cannot source a fact from a credible source, it is n/a - do not guess.

Work to files first, then read them back

The connector response - not your memory of it - is the single source of truth, because context can be compressed mid-task and a half-remembered number is exactly how errors creep in. So: immediately after each tool call returns, write its raw output to a file, before making the next call. Then, before you assemble the snapshot, read every file back and build the report from the files, not from recall. Use a working directory you create once at the start, e.g. em-glance/.

Calculations are explicit, gated, and verified

You compute the derived figures yourself - there is no bundled script - so the discipline has to come from method, not from a black box:

• Gate on reported inputs. Compute a figure only when every input it needs is reported for the relevant year(s). If EBIT is not reported for FY2024, EBIT margin for FY2024 is n/a - never infer it.
• Show the work. Every derived figure gets a footnote with the formula and the actual numbers substituted in, e.g. EBITDA margin (FY2024) = EBITDA ÷ Revenue = 19.4 ÷ 121.6 = 15.9%. A figure a reader cannot recompute from its footnote does not belong in the snapshot.
• Verify before you use. For any multi-step figure (e.g. a CAGR), write the steps out and check the intermediate result before relying on it. When in doubt, recompute from the raw file rather than reusing a number you calculated earlier.

Calculation methods (use these exact definitions)

All margins are expressed as % of revenue for the same fiscal year:

• Gross margin (FYn) = Gross profit ÷ Revenue
• EBITDA margin (FYn) = EBITDA ÷ Revenue
• EBIT margin (FYn) = EBIT ÷ Revenue
• Net margin (FYn) = Net income ÷ Revenue

Growth (only across years where revenue is reported at both endpoints):

• Revenue YoY (FYn) = (Revenue_FYn − Revenue_FYn-1) ÷ Revenue_FYn-1
• Revenue CAGR, full span = (Revenue_latest ÷ Revenue_earliest)^(1 ÷ (Y−1)) − 1, where Y = number of reported revenue years in the span.
• Revenue CAGR, L3Y = (Revenue_FYn ÷ Revenue_FYn-3)^(1 ÷ 3) − 1 (needs four consecutive reported years).

State the exact years used in every growth footnote, because spans differ when filings are incomplete.

Source attribution: name the underlying provider

Economic Mind aggregates filings from underlying providers, and each line item carries its own source (e.g. "Proff (NO)", "S&P Capital IQ"). Name the underlying provider and say it was gathered through Economic Mind - e.g. "Company filings via Proff (NO), gathered through Economic Mind" - rather than crediting "Economic Mind" as if it were the primary source. This mirrors how the figure is actually sourced and lets the reader trace it.

Workflow

Phase 1 - Resolve the company & set up

1. Create the working directory once: mkdir -p em-glance.
2. search_companies(["<name>"]). Pick the entity matching the user's intent, using headquarters and summary to disambiguate. If two are plausible, say which you chose and why; if genuinely ambiguous, ask before continuing.
3. Write em-glance/company-info.txt with: companyId, companyName, headquarters, the EM summary, and the currency you will use.

Phase 2 - Pull the financials (one currency, five years)

1. Request the five most recent years including the latest: get_company_financials([id], years=[2021,2022,2023,2024,2025], currency=<one currency>). Use one currency so the years are comparable. (Adjust the year list over time; the latest EM year is the most recent one returned.) If fewer years are reported, that is fine - the snapshot shows exactly what is filed.
2. Immediately write the raw connector JSON to em-glance/<id>-financials.json - before anything else.
3. From that JSON, write a tidy em-glance/financials.csv, one row per (year, line_item), keeping the per-item provider so attribution survives. Leave the value blank where a line item is not reported - do not fill it. Include the source on every row:

   year,line_item,value,source
   2024,revenue,121.6,Proff (NO)
   2024,gross_profit,,not reported
   2024,ebitda,19.4,Proff (NO)
   2024,ebit,18.6,Proff (NO)
   2024,net_income,14.1,Proff (NO)
   2023,revenue,105.9,Proff (NO)
   ...
   

Phase 3 - Web-search the profile facts (cited)

Collect what you can with a source for each: founded, CEO, ownership, employees, listing status, and a 2-3 sentence "about". Start with the EM summary (attribute it as such), then actively web-search for the facts EM does not carry - especially CEO and employee count.

Rules for these searches (this is the only place the web is used, and only for qualitative context):

• Use the WebSearch / web_fetch tools only. Prefer credible primary sources: the company's own website / About / leadership page, official registries (e.g. Brønnøysund/Proff for Norway, Companies House for the UK, SEC filings), annual reports, or established business press (Reuters, Bloomberg, FT, national broadsheets). Avoid scraped aggregators (random LinkedIn-scraper sites, ZoomInfo-style estimate pages, open wikis) unless nothing better exists - and if you must use one, label the fact an estimate.
• No hallucination. If a credible source does not give you the fact, write n/a and move on. Never invent a CEO, a headcount, or a founding year, and never carry one over from a similarly-named company. A confident-looking guess is worse than an honest n/a. Ranges are fine if sourced as such (~250).
• Write em-glance/profile-facts.txt, one fact per block, capturing the source URL:

  FACT: Founded
  VALUE: 1938
  SOURCE: Sperre.com – company history
  URL: https://www.sperre.com/about
  ---
  FACT: CEO
  VALUE: n/a
  SOURCE:
  URL:
  

Phase 4 - Verification & calculations (do not skip)

Work from the files, not from memory.

1. Read every file back: cat em-glance/company-info.txt, cat em-glance/financials.csv, cat em-glance/profile-facts.txt.
2. Compute the derived figures from the CSV using the definitions above, only where the inputs are reported. For each, capture the formula and the exact inputs in em-glance/calculations.csv:

   metric,value,formula,components
   ebitda_margin_FY2024,15.9%,EBITDA÷Revenue,"EBITDA=19.4,Revenue=121.6"
   rev_cagr_L3Y,+0.8%,(Rev_FY2024÷Rev_FY2021)^(1/3)−1,"Rev_FY2024=121.6,Rev_FY2021=118.8"
   

3. Cross-check: re-substitute each formula and confirm it yields the stated value; confirm every figure's inputs are actually present (not blank) in financials.csv; confirm each growth figure names real, reported endpoint years. If a check fails, fix the figure or mark it n/a - do not ship a number you could not verify.

Phase 5 - Assemble the deliverable

Build the Markdown snapshot and a JSON sidecar from the files. Do not re-key a number from memory; pull every value from financials.csv / calculations.csv and every fact from profile-facts.txt.

Markdown structure (this is data, so keep it plain - the client styles it):

# <Company> - company at a glance
*Snapshot generated <date>. Financials reported via <provider(s)>, gathered through Economic Mind, and
computed deterministically; profile facts web-sourced and individually cited. AI-generated - confirm
against the underlying filings before relying on it for a decision.*

## About
<2–3 sentences>  (Source: <where it came from>)

## Key facts
- **Founded:** 1938  (Sperre.com – company history)
- **CEO:** n/a
- **Employees:** ~250  (Proff.no register, 2024)
- **Ownership:** … (…)
- **Listing:** … (…)

## Reported financials by year (<currency> m)
| Line item    | FY2021 | FY2022 | FY2023 | FY2024 | FY2025 |
|--------------|-------:|-------:|-------:|-------:|-------:|
| Revenue      |  118.8 |  155.3 |  105.9 |  121.6 |   n/a  |
| Gross profit |    n/a |    n/a |    n/a |    n/a |   n/a  |
| EBITDA       |   28.5 |   32.6 |   19.1 |   19.4 |   n/a  |
| EBIT         |    …   |    …   |    …   |   18.6 |   n/a  |
| Net income   |    …   |    …   |    …   |   14.1 |   n/a  |
*Blank/n/a = not reported by Economic Mind. Source per line: <provider>.*

## Key figures
- **Latest revenue (FY2024):** <cur> 121.6 m
- **EBITDA margin (FY2024):** 15.9% [^1]
- **EBIT margin (FY2024):** 15.3% [^2]
- **Revenue CAGR (L3Y, FY2021–24):** +0.8% [^3]
*(any figure whose inputs are unreported is shown as n/a, not omitted silently)*

## Calculation footnotes
[^1]: EBITDA margin (FY2024) = EBITDA ÷ Revenue = 19.4 ÷ 121.6 = 15.9%
[^2]: EBIT margin (FY2024) = EBIT ÷ Revenue = 18.6 ÷ 121.6 = 15.3%
[^3]: Revenue CAGR L3Y = (121.6 ÷ 118.8)^(1/3) − 1 = +0.8%

## Sources & method
- **Financials** - <line items> reported by <provider(s)> (e.g. Proff (NO)), gathered through Economic
  Mind; margins and CAGR computed from those reported figures (formulas in footnotes).
- **<each profile fact>** - <source>, <URL>.
- **Not reported by Economic Mind:** <list the gaps, e.g. gross profit all years; FY2025 not yet filed>.

JSON sidecar (em-glance/<id>-glance.json) - a machine-readable mirror so the client can render without re-parsing prose:

{
  "company": "Sperre AS",
  "currency": "NOK",
  "about": {"text": "...", "source": "..."},
  "facts": [{"k": "Founded", "v": "1938", "src": "Sperre.com – company history", "url": "..."}],
  "financials": [{"year": 2024, "revenue": 121.6, "ebitda": 19.4, "ebit": 18.6, "net_income": 14.1,
                  "gross_profit": null, "source": "Proff (NO)"}],
  "figures": [{"metric": "ebitda_margin", "year": 2024, "value": 15.9,
               "formula": "EBITDA÷Revenue", "inputs": {"EBITDA": 19.4, "Revenue": 121.6}}],
  "not_reported": ["gross_profit (all years)", "FY2025 (not yet filed)"]
}

Phase 6 - Deliver

Hand back the Markdown and the JSON. When presenting the output files (via present_files where available, e.g. Claude.ai), list the JSON sidecar (em-glance/<id>-glance.json) first and the Markdown snapshot last, so the human-readable snapshot is the final, most prominent artifact. In any prose summary, reference the figures the snapshot produced - do not re-key or re-round numbers, and do not introduce a figure that is not in the files.

What makes it trustworthy

Every financial number is reported (provider named) or n/a; nothing is sourced from the web or memory. Every derived figure is gated on reported inputs and footnoted with its formula and the exact numbers, so it is independently recomputable. Every profile fact is web-searched from a credible source and cited with its URL, and never touches a calculation. And the whole snapshot is built from files written at collection time, not from potentially-compressed recall - so what you read is what was filed.