# Earnings Call Analysis

Extracting signal from earnings call transcripts — guidance, tone, evasion and deviation from prepared remarks.

**Rests on:** Data Cleaning, Financial Sentiment

*Applied Domains · AI in Finance*


## Why learn this

This skill lets you see what company executives mean when they speak publicly, using tools that can read every quarterly report instantly. You might not have time to listen to three-hour conference calls yourself, but an AI system trained on this principle can highlight exactly where a CEO is hiding worries or exaggerating confidence. Understanding how to build and trust these systems matters because investment decisions often hinge on subtle cues in language—cues that are easy to miss in the rush of news and numbers. For example, if a company’s CEO consistently uses more cautious words during Q&A sessions than in their prepared remarks, an automated system can flag this discrepancy before the market reacts, giving you a clearer picture of the underlying business health.


## The intuition

Every three months, a public company invites analysts and investors to a phone call. The CEO and CFO read a prepared statement, then answer questions. The prepared statement is carefully written, often by lawyers to protect the company from liability. The questions are not; they come from impatient analysts seeking raw data. What the executives say in the Q&A is where the real information lives—they have to respond on the spot, and their words reveal what they truly believe. An earnings call analyst reads the transcript and looks for four specific things:

1. **Future Earnings Predictions**: The company explicitly states what it expects to earn in future quarters.
2. **Confidence Level**: How certain or worried the executives sound when speaking.
3. **Evasion**: Whether they avoid answering a direct question entirely.
4. **Inconsistency**: Whether they say something different from what they prepared in their script.

This is not about reading minds—it is about finding specific, measurable patterns in the words. Consider this concrete case: In a recent quarter, Company X’s CEO stated in the prepared remarks that 'profit margins remain strong.' However, when asked about rising supply costs during the Q&A, they responded with 'We are carefully monitoring input fluctuations and adjusting strategies accordingly.' A human analyst notes the shift from 'strong' to 'monitoring.' An AI system can do this at scale, reading every call from every company, and notice these micro-shifts that a tired human would miss. But the machine needs to be taught what to look for, and it needs the same discipline a human analyst would have: you can only use information that was available at the time the call happened, not the future.

To ensure fairness, analysts must adhere to strict timing rules. They cannot use news reports released after the call to interpret the words spoken during it. They must also only rely on parts of the transcript that are officially part of the public record—these are called admissible evidence spans. This ensures that the analysis is grounded in what was actually said and known at that moment.


## An analogy

Imagine you are a detective interviewing a suspect (the CEO). You have a written statement (the prepared remarks) that the suspect prepared in advance, with a lawyer. You ask questions. The suspect answers. You look for: does the answer match the statement? If the suspect says 'we are confident about next year' but then when asked about a specific risk says 'we are monitoring it closely', that is a tone shift. If you ask 'did you lose money on this project?' and the suspect says 'we are focused on the long term', that is evasion. The analogy stops working because a machine cannot read body language or hear a shaky voice—it only has the words. But the words carry signal anyway: the length of an answer, the number of hedging words ('might', 'could', 'maybe'), and the difference between the prepared text and the live answer. Unlike a detective, the machine does not get tired and can analyse every call in the market, not just one interview.


## Definition

Earnings call analysis is the process of extracting predictive signal from the transcripts of a company's quarterly conference call with investors, focusing on the unscripted question-and-answer section, where guidance, tone, evasion, and deviation from prepared remarks reveal information that the market has not yet priced.


## How it connects

This topic sits at the entry point of 'AI in Finance', showing how natural language processing is applied to business data. It directly connects to 'Specialized Language Models' like FinBERT and BloombergGPT, which are AI systems trained specifically on financial documents rather than general internet text, allowing them to understand nuanced business terms better than standard models. It also connects to 'Strategy Verification', where you test these insights against past market movements to see if the signals actually predicted price changes before moving forward.


## The mathematics

The mathematics we use here is basic arithmetic: counting, dividing, and comparing percentages. We are not predicting the future or measuring uncertainty with probability. We are simply summarizing what happened in the text of an earnings call.

We look at two parts of the call: the prepared remarks (the script the CEO read) and the Q&A section (the live answers to questions). For each part, we count two things:
1. The total number of words.
2. The number of 'hedging' words (words that show uncertainty, like 'might', 'could', or 'possibly').

From these counts, we calculate a 'hedging rate'. This is just a fraction: the number of hedging words divided by the total number of words. It tells us how often the speaker used uncertain language.

We then compare the two rates. We want to know if the CEO became more uncertain during the Q&A than in the prepared script. To do this, we calculate the 'percentage change' from the prepared rate to the Q&A rate. This number tells us how much bigger (or smaller) the uncertainty was in the live answers compared to the script.

We also calculate the 'average answer length'. This is the total number of words spoken in the Q&A divided by the number of questions asked. It tells us, on average, how long the CEO's answers were.


## A worked example

Let us walk through a specific example with real numbers.

**The Data:**
- Prepared remarks: 500 words total. We count 10 hedging words ('might', 'could', etc.).
- Q&A section: 1,000 words total. We count 45 hedging words.
- In the Q&A, the CEO answered 20 questions. The total word count for these answers was 600 words.

**Step 1: Calculate the hedging rate for the prepared remarks.**
The hedging rate is the number of hedging words divided by the total words.
Rate = 10 / 500
To make this easier to read, we can write it as a decimal or a percentage.
10 divided by 500 equals 0.02.
As a percentage, this is 2%. This means 2% of the prepared script contained hedging words.

**Step 2: Calculate the hedging rate for the Q&A section.**
We do the same calculation for the live answers.
Rate = 45 / 1,000
45 divided by 1,000 equals 0.045.
As a percentage, this is 4.5%. This means 4.5% of the Q&A section contained hedging words.

**Step 3: Compare the two rates using percentage change.**
We want to know how much the rate changed from the prepared script (2%) to the Q&A (4.5%). The formula for percentage change is:
((New Value - Old Value) / Old Value) * 100

Here, the 'Old Value' is the prepared rate (2) and the 'New Value' is the Q&A rate (4.5).
First, find the difference: 4.5 - 2 = 2.5.
Next, divide by the old value: 2.5 / 2 = 1.25.
Finally, multiply by 100 to get the percentage: 1.25 * 100 = 125%.

The hedging rate increased by 125%. This is a large jump. It suggests that when answering questions live, the CEO used significantly more uncertain language than in the prepared script.

**Step 4: Calculate the average answer length.**
We want to know how long, on average, each answer was.
Total words in Q&A = 600.
Number of answers = 20.
Average = 600 / 20.
600 divided by 20 equals 30.

**Result:**
The Q&A section had a hedging rate of 4.5%, which is 125% higher than the prepared statement's 2%. This measurable increase in uncertainty is a signal that the CEO was less confident during the live questions. The average answer length was 30 words, which gives us a baseline for how detailed the answers were.


## From scratch, in Python

```python
# We need two things: a list of hedging words to look for,
# and the transcript split into sections.

hedging_words = ["might", "could", "maybe", "possibly", "roughly", "approximately"]

# The transcript is a string of text. We'll split it in two parts.
prepared_text = "We are confident about next year. We expect to grow."
qa_text = "We might see some growth, but it could be slower than expected."

# Step 1: Count words in each section.
# In Python, a string has a method called .split() that breaks it into a list of words.
prepared_words = prepared_text.split()
qa_words = qa_text.split()

print(prepared_words)  # ['We', 'are', 'confident', 'about', 'next', 'year.', 'We', 'expect', 'to', 'grow.']
print(qa_words)       # ['We', 'might', 'see', 'some', 'growth,', 'but', 'it', 'could', 'be', 'slower', 'than', 'expected.']

# Step 2: Count hedging words.
# A 'for' loop goes through each word in the list, one by one.
hedge_count_prepared = 0
for word in prepared_words:
    if word in hedging_words:  # 'in' checks if the word is in our list
        hedge_count_prepared = hedge_count_prepared + 1

hedge_count_qa = 0
for word in qa_words:
    if word in hedging_words:
        hedge_count_qa = hedge_count_qa + 1

print(hedge_count_prepared)  # 0
print(hedge_count_qa)        # 2

# Step 3: Calculate rates.
# len() gives the total number of words in the list.
rate_prepared = hedge_count_prepared / len(prepared_words)
rate_qa = hedge_count_qa / len(qa_words)

print(rate_prepared)  # 0.0
print(rate_qa)        # 0.2  (2 out of 10 words are hedging)

# Step 4: Deviation score.
deviation = rate_qa / rate_prepared if rate_prepared != 0 else None
print(deviation)  # None, because we cannot divide by zero—the prepared remarks had no hedging
# In this small example, the prepared text had zero hedging, which breaks the ratio.
# In a real analysis, we would add one tiny smoothing term to avoid division by zero.

# Step 5: Average answer length.
# We have a list of answer word counts. A function to compute the average:
def average(numbers):
    total = 0
    for n in numbers:
        total = total + n
    return total / len(numbers)

answer_lengths = [20, 30, 40, 25, 35]
print(average(answer_lengths))  # 30.0

# Step 6: Evasion score—if a question is about a specific topic, a short answer might be evasion.
# We'll just check how many answers are shorter than 15 words.
short_answers = [length for length in answer_lengths if length < 15]
print(short_answers)  # [] (none here)

```


## What the code does

The code starts by defining a list of hedging words and two example texts. The .split() method is a built-in function on strings that divides the text on spaces and returns a list of words—this is how we get a list usable with a for loop. The for loop goes through each word, and the 'in' operator checks membership in the hedging_words list. The counters are incremented by 1 each time we find a match. Then we compute rates by dividing the count by the total number of words. The deviation ratio has a guard against division by zero—in practice we would add a small constant to both rates to avoid this. The average function uses a loop to sum the list, then divides by the length. The list comprehension at the end filters for short answers, which is a simple way to flag potential evasion.


## Common misconceptions

**The prepared remarks carry the most signal** — The CEO carefully writes the prepared statement, so that must be the most honest part. The Q&A is just them repeating the same thing.

The prepared remarks are scripted and reviewed by lawyers. The Q&A is unscripted, and the executive has to think on the spot. Unscripted speech reveals more about true uncertainty. In fact: The Q&A section is where the signal lives—it is less filtered and contains higher variance. The prepared remarks serve as a baseline to compare against.

**Hedging words mean the company is lying** — If the CEO says 'we might grow', they are hiding something.

Hedging is a normal part of cautious language, especially in regulated settings. It only becomes a signal when it deviates from the typical tone or from the prepared remarks. In fact: Hedging is a measurable feature of uncertainty, not a lie detector. The signal is the deviation from the baseline, not the hedging in isolation.

**A shorter answer always means evasion** — If the CEO gives a one-word answer, they are evading the question.

Some questions are simple and deserve short answers. Evasion is a pattern: shying away from a specific question that the prepared remarks addressed in detail, or refusing to give the requested number. In fact: Evasion is detected by comparing answer length and content against the prepared remarks and the question specifics. A short answer to a question that the prepared remarks covered at length is more suspicious.

**One can use today's stock price to evaluate yesterday's call** — I can see whether the model's tone score predicted the price by looking at the price after the call—that's the ground truth.

This is lookahead bias. The price after the call only exists in the future, and using it in training or evaluation invalidates the analysis. Your library calls this 'point-in-time discipline'. In fact: You must only use information available at the time of the call. The point-in-time discipline is not optional—any evaluation that leaks the future is fiction.


## In short

Earnings call analysis is about digging into the unscripted Q&A section of a company's transcript and finding measurable signals: how hedged the language is, how much it deviates from the prepared script, and how long the answers are. The mathematics is simple arithmetic—word counts and rates. The code is plain Python: split the text, count hedging words, compute ratios. And the discipline is a finance rule: never use information that was not available at the time.


## Where this is used

This concept is used directly in the AI systems that investors and analysts use today. In **large language models**, the same idea of 'deviation from prepared remarks' is implemented as a prompt: give the model the prepared text and the Q&A, and ask it to output a score for hedging, evasiveness, and sentiment. Under the hood, the model computes probabilities over words, and the developer extracts these scores without writing explicit counting loops. A real tool might call an LLM endpoint with a carefully engineered prompt and parse the JSON response. In **small language models running on a phone or laptop**, the developer would use a fine-tuned model like FinBERT (which your library mentions) to classify each sentence as hedging or not, and then aggregate the counts. The developer writes code to load the model, feed it tokenised text, and collect the output probabilities. In **retrieval-augmented generation**, the earnings call transcript is split into chunks, embedded into vectors, and stored in a vector database. When a user asks a question, the system retrieves relevant chunks and uses the LLM to answer with citations to the specific lines in the transcript—this is the 'admissible evidence span' your library mentions. The developer writes code for chunking, embedding, and retrieval, and then a final prompt to generate the answer. In **agentic systems that plan and call tools**, the agent might first retrieve the transcript, then call a financial calculator to compute percentage changes, then synthesise a report. The developer defines the tools (e.g., a function that fetches a transcript and a function that computes the hedging ratio) and the agent decides when to call them. In **everyday applied machine learning**, this same pipeline is used in fraud detection (when a company's comments deviate too much from its financials), in recommendation systems (when an earnings call is positive, the stock is recommended), and in forecasting (combining tone scores with historical data to predict future returns). What breaks when done badly: if the analysis uses information that was not available at the time of the call (e.g., using the actual reported earnings that came out a week later), the backtest is invalid—this is the point-in-time discipline your library stresses. If the model cannot reason about numbers (your library notes that numerical reasoning is a weakness of LLMs), the percentages might be wrong; the fix is to use tool calls for arithmetic. If the model uses a general sentiment model, it will mislabel financial language—'volatility' is not necessarily bad—so you need a domain model like FinBERT. In practice, a developer building this would: (1) fetch the transcript from an API, (2) split the text into sections, (3) call a fine-tuned model for tone classification, (4) compute deviation scores using plain Python or a library like pandas, and (5) store the results with a timestamp to enforce point-in-time discipline.


---

Read this on the web: https://basavapurushottam.com/learn-ai/earnings-call-analysis
