VidEgoThink: Assessing Egocentric Video Understanding Capabilities for Embodied AI

## Abstract

Abstract Recent advancements in Multi-modal Large Language Models (MLLMs) have opened new avenues for applications in Embodied AI.
Building on previous work, EgoThink, we introduce VidEgoThink, a comprehensive benchmark for evaluating egocentric video understanding capabilities.
To bridge the gap between MLLMs and low-level control in Embodied AI, we design four key interrelated tasks: video question-answering , hierarchy planning , visual grounding and reward modeling .
To minimize manual annotation costs, we develop an automatic data generation pipeline based on the Ego4D dataset, leveraging the prior knowledge and multimodal capabilities of GPT-4o.
Three human annotators then filter the generated data to ensure diversity and quality, resulting in the VidEgoThink benchmark.
We conduct extensive experiments with three types of models: API-based MLLMs, open-source image-based MLLMs, and open-source video-based MLLMs.
Experimental results indicate that all MLLMs, including GPT-4o, perform poorly across all tasks related to egocentric video understanding.
These findings suggest that foundation models still require significant advancements to be effectively applied to first-person scenarios in Embodied AI.
In conclusion, VidEgoThink reflects a research trend towards employing MLLMs for egocentric vision, akin to human capabilities, enabling active observation and interaction in the complex real-world environments.

## 1 Introduction

In recent years, Multi-modal Large Language Models (MLLMs; Du et al., ; Gan et al., ; Tang et al., ) have made significant strides in conventional vision-language tasks (Alayrac et al., ; Driess et al., ; Li et al., ), profoundly impacting the field of Embodied Artificial Intelligence (Embodied AI; Ahn et al., ; Kuo et al., ; Huang et al., ; Zitkovich et al., ).
Training data (Sharma et al., ; Schuhmann et al., ; Lin et al., ; Jia et al., ) for predominate MLLMs are typically collected from object-centric and exocentric perspectives, mirroring the distribution of conventional vision-language benchmarks (Liu et al., ; Xu et al., ; Li et al., ; Ning et al., ), which focus primarily on object and scene understanding.
However, to be effectively applied in Embodied AI, it is crucial not only to understand the surrounding environment but also to have extensive knowledge about the relationship between “myself” and the environment.
For example, compared to the absolute position in the whole environment (e.g., “the microwave is in the kitchen”), the relative position to my body is more important (e.g., “the microwave is one meter to my right”) for interaction and manipulation.
Therefore, egocentric videos (Grauman et al., ; Damen et al., ), containing observations typical of third-person perspectives and additional interactions with the surrounding environment, can improve predominate MLLMs to be more general and expand their applications to the real world.

Various egocentric benchmarks (Cheng et al., ; Fan, ), as shown in Table 1, have emerged to evaluate the capabilities of MLLMs from a first-person perspective.
For instance, EgoTaskQA (Jia et al., ) and EgoPlan (Chen et al., ) assess the planning capabilities of MLLMs for long-horizon tasks, while EgoSchema (Mangalam et al., ) aims to diagnose the understanding of very long-form video.
However, the absence of a comprehensive video benchmark from the egocentric perspective presents a significant challenge to the development of general foundation models.
Furthermore, current benchmarks, both in task design and textual output forms, focus on traditional video question-answering settings and neglect the potential to support downstream applications in Embodied AI, such as glass devices or autonomous robots.
For example, the natural language output format (e.g., “put salmon in microwave”) cannot be directly processed by robotics to take actions, whereas bounding boxes of grounded objects (e.g., “microwave [290, 202, 835, 851]” or function calls for low-level actions (e.g., “find(microwave)”) align more closely with the input requirements of robotic control systems.
Therefore, it is crucial to design suitable task formats that can be effectively applied to downstream applications in Embodied AI.

In this paper, we introduce VidEgoThink, as illustrated in Figure 1, a comprehensive egocentric video understanding benchmark aimed at better aligning the capabilities of MLLMs for application in Embodied AI.
Due to the stratospheric demand for training data of end-to-end Vision-Language-Action models (Driess et al., ; Padalkar et al., ; Li et al., ), systems in Embodied AI are always structured into specialized hierarchical components.
In detail, MLLMs can perform several key functions:
(1) video question-answering, the basic module to comprehend the surrounding environment and human activities, and then generate corresponding responses to specific instructions (Cheng et al., ; Fan, ; Jia et al., );
(2) hierarchy planning, the core component to decompose high-level instructions to mid-level sub-goals and low-level actions (Ahn et al., ; Huang et al., ; );
(3) visual grounding, the detector module to help Embodied AI system ground complex instruction to the physical world (Gao et al., ; Chiang et al., ; Munasinghe et al., );
(4) reward modeling, the auxiliary module to classify task completion and further provide feedback according to the observations (Kwon et al., ; Di Palo et al., ; Yu et al., ).
Rather than solely considering traditional question-answering or planning tasks like previous egocentric benchmarks, we specifically design these four tasks to comprehensively evaluate the capabilities for different functions of MLLMs in Embodied AI.

**Table 1: Comparison of recent evaluation benchmarks of multimodal large language models and our proposed benchmark VidEgoThink. VQA/HP/VG/RM indicate visual question answering, hierarchy planning, visual grounding, and reward modeling. Existing/Handcraft/Automatic denote the way of collecting data, including existing dataset, manual annotation, and automatic generation.**
| Benchmark | Comprehensive<br>Capabilities | View | Task Type | Data<br>Source | Average<br>Length | Total<br>Size |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Observe | Interact | VQA | HP | VG | RM |  |  |  |  |  |
| ActivityNet-QA | ✗ | ✓ | ✗ | ✓ | ✗ | ✗ | ✗ | Handcraft | 180s | 58,000 |
| SEED-Bench-2 | ✓ | ✓ | ✗ | ✓ | ✗ | ✗ | ✗ | Handcraft | - | 24,000 |
| AutoEval-Video | ✓ | ✓ | ✗ | ✓ | ✗ | ✗ | ✗ | Handcraft | 14.58s | 327 |
| Video-Bench | ✓ | ✓ | ✗ | ✓ | ✗ | ✗ | ✗ | Existing | - | 15,000 |
| Perception Test | ✗ | ✓ | ✗ | ✓ | ✗ | ✓ | ✗ | Handcraft | 23s | 11,600 |
| OpenEQA | ✗ | ✓ | ✗ | ✓ | ✗ | ✗ | ✗ | Handcraft | - | 1,600 |
| MVBench | ✓ | ✓ | ✓ | ✓ | ✗ | ✗ | ✗ | Existing | (5s, 35s) | 4,000 |
| EgoVQA | ✗ | ✓ | ✓ | ✓ | ✗ | ✗ | ✗ | Handcraft | (20s, 100s) | 520 |
| EgoThink | ✓ | ✗ | ✓ | ✓ | ✓ | ✗ | ✗ | Handcraft | - | 700 |
| EgoTaskQA | ✗ | ✗ | ✓ | ✓ | ✗ | ✗ | ✗ | Automatic | 25s | 40,000 |
| EgoPlan-Bench | ✗ | ✗ | ✓ | ✗ | ✓ | ✗ | ✗ | Automatic | - | 3,400 |
| EgoSchema | ✗ | ✗ | ✓ | ✓ | ✗ | ✗ | ✗ | Automatic | 180s | 5,000 |
| VidEgoThink (Ours) | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | Automatic | 270.74s | 4,993 |

Considering the high cost of manually labeling data for four different tasks, we design a series of automatic construction pipelines leveraging existing annotations from the Ego4D dataset (Grauman et al., ).
we use GPT-4o, known for its superior reasoning capabilities, to generate appropriate question-answering pairs by combining our designed prompts with existing human annotations.
For the reward modeling task, we further adopt clipped images from each video to generate feedback for negative instances.
To ensure diversity and quality, three annotators are asked to filter the automatically generated instances.
For evaluation, we extensively compare 14 MLLMs across three categories: API-based MLLMs, open-source image-based MLLMs, and open-source video-based MLLMs.
Experimental results indicate that all MLLMs perform poorly across all tasks.
For example, GPT-4o with 32 frames and 8 frames achieve only 31.17% and 32.83% accuracy in video question-answering tasks.
Detailed scores reveal that while MLLMs can determine existence across object, action, and scene dimensions, they particularly lack the ability to judge order or sequence.
In other tasks, although GPT-4o’s performance is subpar, other open-source MLLMs are almost completely unusable, showing significant performance gaps.
Overall, applying current MLLMs directly to first-person scenarios in Embodied AI remains challenging and requires further effort.
However, MLLMs hold great potential for advancing Egocentric Vision and Embodied AI, offering ample room for exploration and improvement.

## 2 Related Work

Multi-modal Large Language Models.
The advancement of large language models (LLMs; Brown et al., ; Ouyang et al., ; Wang et al., ) now extend into MLLMs.
Visual modules, such as CLIP (Radford et al., ) and Q-Former (Dai et al., ), are integrated with pre-trained LLMs using various transition layers, equipping them with visual capabilities.
From the wide selection of open-source LLMs, numerous image-based MLLMs (Chen et al., ; Liu et al., ; Zhang et al., ; Dai et al., ; Alayrac et al., ) have emerged.
Moreover, the popularization of these image-based MLLMs has driven advancements in video perception.
Video-based models like Video-LLaVA (Lin et al., ), Vision-LLaMA (Chu et al., ), and PandaGPT(Su et al., ) are capable of capturing the temporal information present in video form.
In this work, we explore egocentric video understanding capabilities of MLLMs.

Video-Langugae Benchmarks.
Numerous video-language benchmarks assess MLLMs, primarily focusing on instruction-following via visual question-answering tasks (Ning et al., ; Li et al., ; Patraucean et al., ).
Few benchmarks explore egocentric videos (Mangalam et al., ; Jia et al., ), like EgoTaskQA (Jia et al., ), EgoPlan-Bench (Chen et al., ), and EgoGoalStep (Song et al., ).
However, they often lack variety in assessed capabilities.
EgoThink (Cheng et al., ) covers more comprehensive capabilities but uses static images.
Moreover, all these egocentric benchmarks with only conventional VQA tasks neglect that the designed task format should be grounded in the potential applications.
Therefore, in this paper, we focus on comprehensively exploring the capabilities for different functions of MLLMs in Embodied AI.
A comparison to recent video-language benchmarks is presented in Table 1.

Egocentric Video Datasets.
Egocentric video datasets (Grauman et al., ; Damen et al., ; Pirsiavash & Ramanan, ; Sigurdsson et al., ) capture first-person interactions with environment, aiding robotic tasks and augmented reality.
These datasets are often recorded via head-mounted cameras or wearable glasses.
As more egocentric videos become available, specialized datasets focusing on specific aspects of ego-perspective have emerged.
For instance, LEMMA (Jia et al., ) includes data on goal-directed actions and multi-task situations.
Ego-ExoLearn (Huang et al., ) and Ego-Exo4D (Grauman et al., ) emphasize egocentric videos that demonstrate an individual’s understanding of activities when given an exocentric demonstration.
These datasets provide a robust foundation for training and evaluating MLLMs from a first-person perspective.

## 3 Task Types in VidEgoThink

Given that the utilization of foundation models in Embodied AI remains an open research question, we carefully design four types of interrelated tasks for comprehensive assessment as shown in Figure 1: (i) video question-answering (Cheng et al., ; Fan, ; Jia et al., ), (ii) hierarchy planning (Ahn et al., ; Huang et al., ; ), (iii) visual grounding (Gao et al., ; Chiang et al., ; Munasinghe et al., ), and (iv) reward modeling (Kwon et al., ; Di Palo et al., ; Yu et al., ).
The detailed descriptions of four different tasks are as follows.

### 3.1 Video Question Answering

Previous evaluation studies on egocentric vision (Cheng et al., ) have predominantly focused on static images, constrained by the input format limitations of earlier MLLMs.
However, recent advancements in API-based and video-based MLLMs (Achiam et al., ; Anthropic, ; Reid et al., ; Li et al., ; Lin et al., ) have demonstrated significant progress.
Since our real world is inherently dynamic and humans frequently process substantial amounts of video data, it is crucial to evaluate the video understanding capabilities of MLLMs.

#### Dimensions.

To underscore the differences between static images and dynamic videos (Li et al., ), we emphasize temporal attributes, ensuring that questions require the entire video for accurate answers rather than just a single frame.
Considering the essential abilities for observing and interacting with the real world from a first-person perspective, we decompose the content of video modalities around “myself” into three main elements: object, action, and scene.
Furthermore, we explore a series of fine-grained dimensions from these elements as shown in Figure 2.

Figure: Figure 2: Case of video question answering.
Refer to caption: x2.png

- •
Object.
Observing and interacting with objects are fundamental capabilities of the human visual system.
Egocentric videos emphasize the objects seen or used by “myself”.
We further divide the object category into six fine-grained dimensions:
(1) Object Existence (OE): Determining whether an object has appeared in the video;
(2) Object Order (OO): Identifying the sequence of objects appearing in the video;
(3) Object Interaction (OI): Assessing whether and how an object has been used in the video;
(4) Object Count (OC): Counting the total number of objects for a specific type;
(5) Object State (OS): Assessing whether the state of an object has changed;
(6) Object Prediction (OP): Predicting what will happen to a certain object.
- •
Action.
Action recognition involves automatically identifying specific human actions within the video.
Egocentric videos emphasize events that involve interactions with “myself”.
Since action prediction is important and has become a standard task in Embodied AI, we will elaborate on it in Section 3.2.
We further divide the action dimension into three fine-grained dimensions:
(1) Action Existence (AE): Determining whether an action has happened in the video;
(2) Action Sequence (AS): Identifying the sequence in which actions occur in the video;
(3) Action Count (AC): Counting the frequency with which an action occurs.
- •
Scene.
Perceiving the surrounding scene from a first-person perspective is essential for interacting with the environment.
In egocentric video data, the constant movements of my body and viewpoint make describing an object’s position relative to one’s orientation challenging, necessitating integration with the environmental context.
We have also designed three fine-grained dimensions to perceive the scene:
(1) Scene Existence (SE): determining whether the video takes place in a certain scene;
(2) Scene Transition (ST): Identifying the transitions between scenes visited;
(3) Scene Prediction (SP): Predicting where the next scene will take place.

#### Task Format.

Two mainstream methods for video question-answering include multiple-choice and open-ended question-answering.
Compared to multiple-choice, open-ended text generation is more natural in real-world applications.
Moreover, it is difficult to design distractors in multiple-choice question-answering to ensure that there are no inherent shortcuts.
Therefore, we mainly adopt open-ended text generation as our task format for traditional video question-answering.

- •
Open-Ended Question-Answering.
Given an egocentric video $i$ along with a question $q_{i}$, the model is asked to generate responses $r_{i}$ in free-text form, akin to human communication. The generate answer $r_{i}$ is then compared to its corresponding ground-truth response $r_{i}^{gt}$.

#### Metrics.

Traditional metrics (Chen et al., ; Papineni et al., ) fall short in accurately assessing semantic similarity.
Follwing Zheng et al. (), we employ API-based LLMs as automatic evaluators (Acc-VQA) to assess the performance of generated answers.
These evaluators have demonstrated high correlations with human labels (Zheng et al., ; Cheng et al., ), making them a reliable substitute for human assessment.

- •
Acc-VQA.
Given the limitations of traditional metrics, we use API-based LLMs $g(\cdot)$ with superior reasoning abilities to evaluate open-ended answers.
Specifically, we assign the score $g(\hat{r}_{i},r_{i})$ as 0 (wrong), 0.5 (partially correct), or 1 (correct) to the generated response $\hat{r}_{i}$ with reference to the question $q_{i}$ and the corresponding ground-truth response $r_{i}$.
The performance of benchmark $\mathcal{D}$ is then computed by averaging all scores as follows:
$\displaystyle\text{Acc-VQA}=\frac{1}{|\mathcal{D|}}\sum_{i=1}^{|\mathcal{D}|}g
(\hat{r}_{i},r_{i}),\;g(\hat{r}_{i},r_{i})=\begin{cases}1&\text{correct}\\
0.5&\text{partially correct}\\
0&\text{incorrect}\end{cases}$
(1)

### 3.2 Hierarchy Planning

Recently, a hierarchy planning framework (Ahn et al., ; Singh et al., ; Vemprala et al., ) has been proposed to combine the advantages of foundation models and traditional methods in Embodied AI.
In detail, foundation models are used as the planner to decompose high-level task instructions (e.g., “cook salmon”) into either mid-level steps (e.g., “# put salmon in the microwave’) or low-level atomic actions (e.g., “find(microwave)”), which is much more convenient for controlling.
Despite EgoPlan-Bench (Chen et al., ) exploring the planning capability from the first-person perspective, it only considers decomposing the high-level goal into mid-level steps, and its task format is multi-choice which is less natural.

Figure: Figure 3: Case of hierarchy planning.
Refer to caption: x3.png

Task Format. As illustrated in Figure 3, we design two types of planning tasks: high-level goal to mid-level step (High-to-Mid), and mid-level step to low-level action (Mid-to-Low).

- •
High-to-Mid.
Given an egocentric video $i$ with historical and current observations, a high-level goal $G_{i}$, MLLMs are required to generate the next step $\hat{s}_{i}$ in free-text format. This generated step is then compared to the ground-truth step $s_{i}$ that follows the provided video.
We adopt a step-by-step format rather than directly generating the entire long-term plan because our focus is on evaluation rather than method development.
- •
Mid-to-Low.
Given a pre-defined set of low-level atomic actions $\mathcal{A}$ that encompasses common functions in daily human activities, an egocentric video $V_{i}$, and the ground-truth of a mid-level step $s_{i}$ that is yet to be complete, MLLMs are required to generate the trajectory of low-level actions $\hat{\mathcal{T}}_{i}=(\hat{a}_{1},\cdots,\hat{a}_{n})$ using functions from $\mathcal{A}$ to complete the mid-level step. The corresponding ground-truth trajectory of actions that appeared after the provided video is $\mathcal{T}_{i}=(a_{1},\cdots,a_{m})$.

Metrics.
Considering the difficulty of hierarchical planning tasks, we directly use API-based LLMs to compute accuracy (Acc-H2M and Acc-M2L).
However, these metrics are a trade-off due to the challenges of evaluation video planning tasks. We will introduce an advanced version in future work, as discussed in Sec. 6.

- •
Acc-H2M. In the high-to-mid task, we apply API-based LLMs $g(\cdot)$ to compute the similarity score $g(\hat{s}_{i},s_{i})$ between generated step prediction $\hat{s}_{i}$ and ground truth $s_{i}$ for the benchmark $\mathcal{D}$. Specifically, we also assign the score $s_{i}$ as 0 (wrong), 0.5 (partially correct), or 1 (correct).
$\displaystyle\text{Acc-H2M}=\frac{1}{|\mathcal{D}|}\sum_{i=1}^{|\mathcal{D}|}g
(\hat{s}_{i},s_{i})\;,\;\;g(\hat{s}_{i},s_{i})=\begin{cases}1&\text{correct}\\
0.5&\text{partially correct}\\
0&\text{incorrect}\end{cases}$
(2)
- •
Acc-M2L. For the Mid-to-Low task, which is akin to tool learning (Guo et al., ; Qin et al., ) by calling low-level functions and evaluating the success rate, we also use API-based LLMs to determine the completion status. We assign the score $g(\mathcal{\hat{T}},\mathcal{T})$ to compute the similarity between the generate action trajectory $\mathcal{\hat{T}}$ and the ground-truth trajectory $\mathcal{T}$, using a scale from 0 to 10 to increase the degree of differentiation.
$\displaystyle\text{Acc-M2L}=\frac{1}{|\mathcal{D}|}\sum_{i=1}^{|\mathcal{D}|}g
(\mathcal{\hat{T}},\mathcal{T})\;,\;\;0\leq g(\mathcal{\hat{T}},\mathcal{T})
\leq 10$
(3)

### 3.3 Visual Grounding

While natural language is effective for human communication, it cannot be directly translated into low-level actions or grounded in the real world.
Consequently, visual grounding (Peng et al., ; Chen et al., ; Munasinghe et al., ) has garnered significant attention in both image- and video-based MLLMs.
This task requires models to ground complex natural language descriptions or instructions in an image or video and output the corresponding pixel-level bounding boxes, masks, or frames.
The bounding boxes and masks can directly identify actionable objects (Munasinghe et al., ; Zheng et al., ), while the frames can provide sufficient spatial or temporal information for downstream tasks (Li et al., ; Chiang et al., ).

Figure: Figure 4: Cases of visual grounding.
Refer to caption: x4.png

#### Task Format.

Although RefEgo (Kurita et al., ) considers object tracking from the first-person perspective, its output format is designed for conventional computer vision methods rather than MLLMs.
To bridge this gap, we specifically design three tasks for different situations as shown in Figure 4: object grounding, frame grounding, and temporal grounding.

- •
Object Grounding.
Given an egocentric video $i$ and a natural language query $q_{i}$ of an object, the model is required to provide a bounding box represented as a rectangle $B_{i}=\left[x_{1},x_{2},y_{1},y_{2}\right]$ containing the query object in the last frame of the video.
Performance is evaluated by comparing with the ground truth $B_{i}^{gt}=\left[x_{1}^{gt},x_{2}^{gt},y_{1}^{gt},y_{2}^{gt}\right]$.
It is worth noting that the query $q_{i}$ is designed according to the whole video rather than only the last frame.
Locating target objects that appeared earlier in the observed frame is crucial for downstream tasks, like manipulation and navigation.
- •
Frame Grounding.
Given an egocentric video $i$ and a natural language query $q_{i}$, the model is asked to identify the keyframe $K_{i}$ containing the required information, which will be compared with the set of ground-truth keyframes $\{K_{ij}^{gt}\}$ in a small enough time interval of the last appearance of the target. That is, if an object or action occurs multiple times, we specify the time interval of the last appearence time as the ground truth, as it generally contains the most useful information for the current situation.
In embodied scenes, there is always a need to retrieve objects, people, or events that occurred earlier.
- •
Temporal Grounding. Given an egocentric video $i$ and a natural language query $q_{i}$, the model is required to identify the time segments in the video corresponding to the query, represented as $T_{i}=\left[l_{i},r_{i}\right]$, where $0\leq l_{i}\leq r_{i}\leq|V_{i}|$, and $|V_{i}|$ is the total number of frames in the video.
The ground truth $T_{i}^{gt}$ follows a consistent format.
It is crucial to know the relevant time segment that occurred previously, such as the frequency of an event and the complete trajectory of an object.

#### Metrics.

For object grounding and temporal grounding, we use mean intersection over union (mIoU) as the uniform metric, named mIoU-Object and mIoU-Temporal, respectively.
They calculate the similarity between the output and the ground truth because their output results can be expressed as a certain region or a certain range.
For frame grounding, we use accuracy (Acc-Frame) to evaluate the model output as the answer is an integer.

- •
mIoU-Object.
We denote the bounding box output as $\hat{B}_{i}$ and the ground truth as $B_{i}$, where $i$ represents a sample.
The similarity in the benchmark $\mathcal{D}$ is calculated using mIoU as follows.
$\text{mIoU-Obj}=\frac{1}{|\mathcal{D}|}\sum_{i=1}^{|\mathcal{D}|}\frac{|\hat{B
}_{i}\cap B_{i}|}{|\hat{B}_{i}\cup B_{i}|}$
(4)
- •
Acc-Frame.
Given the keyframe index $\hat{k}_{i}$ produced by the model and its corresponding ground truth set $\mathcal{K}_{i}$, we can calculate the accuracy in the benchmark dataset $\mathcal{D}$ as follows.
Here, $\chi(\cdot)$ is an indicator function that equals 1 if $\hat{k}_{i}$ in $\mathcal{K}_{i}$, and 0 otherwise.
$\text{Acc-Frame}=\frac{1}{\mathcal{|D|}}\sum_{i=1}^{|\mathcal{D}|}\chi_{
\mathcal{K}_{i}}\left(\hat{k}_{i}\right)$
(5)
- •
mIoU-Temporal.
We denote the time interval covered by the model output as $\hat{T}_{i}$ and ground truth as $T_{i}$ respectively, where $i$ represents a video sample. Similarly, we can calculate the score in the benchmark $\mathcal{D}$ as follows.
$\text{mIoU-Temp}=\frac{1}{|\mathcal{D}|}\sum_{i=1}^{|\mathcal{D}|}\frac{|\hat{
T}_{i}\cap T_{i}|}{|\hat{T}_{i}\cup T_{i}|}$
(6)

### 3.4 Reward Modeling

In Embodied AI, manually designing reward functions to supervise actions is challenging due to the need for accuracy and diversity, especially for human activities.
Benefiting from the large-scale Internet training corpus, foundation models can serve as reward models with built-in commonsense and reasoning capabilities.
There are three primary approaches to deploying foundation models as reward models:
(1) Using a sparse proxy reward function with a simple binary score (Kwon et al., );
(2) Computing similarity between close-vocabulary action phrases and images (Di Palo et al., ; Rocamonde et al., );
(3) Generating code to translate task semantics into combined reward functions (Yu et al., ; Ma et al., ).
Considering the feasibility of targeting video data, this paper primarily focuses on the first approach.

Figure: Figure 5: Case of reward modeling.
Refer to caption: x5.png

#### Task Format.

As a reward model, MLLMs should first observe the video to determine the completion status of the target motion. If the action is not completed, the reward model should further provide fine-grained feedback to help achieve the goal inspired by (Wang et al., ; Cheng et al., ).
Hence, we specifically design two types of tasks like Figure 5: critique, and feedback.

- •
Critique. Given an action-specific egocentric video $i$ and its corresponding natural language action description $a_{i}$, the reward model needs to directly generate a binary answer $\hat{y}_{i}$ (i.e., Yes or No) that indicates whether the action has been completed in the observed video.
- •
Feedback.
Given an uncompleted action $a_{i}$ in the $i$-th egocentric video, the reward model needs to provide fine-grained feedback $\hat{r}_{i}$ on why the action is not completed based on current observations, compared to the ground-truth references $\mathcal{R}_{i}=\{r_{i}^{1},r_{i}^{2},r_{i}^{3}\}$.
This feedback is valuable for guiding and correcting downstream models to learn the policy for completing the target action.

#### Metrics.

We apply the following accuracy metrics to assess performance in critique and feedback tasks (Acc-Critique and Acc-Feedback) for the reward modeling tasks.

- •
Acc-Critique. For each critique task in the benchmark $\mathcal{D}$, we compare the generated critique $\hat{y}_{i}$ with its ground-truth label $y_{i}$. The boolean function $\mathbb{I}(\cdot)$ returns one for each identical output label and zero otherwise.
$\displaystyle\text{Acc-Cri}=\frac{1}{|\mathcal{D}|}\sum_{i=1}^{|\mathcal{D}|}
\mathbb{I}(\hat{y}_{i}=y_{i})$
(7)
- •
Acc-Feedback. To quantitatively assess the similarity between the generated feedback $\hat{r}_{i}$ and the set of reference feedback $\mathcal{R}_{i}$, we employ evaluator LLM $g(\cdot)$ that assigns a score with 0 (wrong), 0.5 (partially correct) or 1 (correct).
$\displaystyle\text{Acc-Feed}=\frac{1}{|\mathcal{D}|}\sum_{i=1}^{|\mathcal{D}|}
g(\hat{r}_{i},\mathcal{R}_{i}),\;g(\hat{r}_{i},\mathcal{R}_{i})=\begin{cases}1
&\text{correct}\\
0.5&\text{partially correct}\\
0&\text{wrong}\end{cases}$
(8)

## 4 Data Collection in VidEgoThink

Recent releases of egocentric video datasets (Grauman et al., ; ; Huang et al., ) have advanced the field of Embodied AI.
To ensure diversity and popularity, we use the popular Ego4D dataset (Grauman et al., ) to construct VidEgoThink benchmark.
Ego4D-v2(^1^11https://ego4d-data.org/docs/updates/) contains 3,900 hours of 9,611 egocentric videos with diverse human annotations.
To avoid data leakage, we select videos from the validation dataset.
However, due to the video length limitations of MLLMs, the lengthy Ego4D videos, ranging from tens of minutes to over an hour, are unsuitable.
Additionally, manually labeling question-answering data requires significant human effort.
To address these problems, we design strategies to automatically clip the videos to appropriate lengths and generate corresponding question-answer pairs.
To prevent the VidEgoThink benchmark from being compromised through prompt engineering, the detailed prompts used for automatic annotation construction will not be released.
The statistics of each task in VidegoThink are presented in Table 2.

**Table 2: The statistics of videos across different benchmarks. Duration denotes the average time duration in second of all videos. LenQ and LenA indicate that the average length of questions and answers in the word level. TypeQ denotes the type of questions.**
| Benchmark | Subtask | Video | Question-Answering | #Scene |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| #Original | #Clipped | Duration | #Instance | LenQ | LenA | TypeQ |  |  |  |
| Video Question Answering | Object | 29 | 57 | 23.71 | 300 | 10.88 | 7.13 | 5 | 9 |
| Action | 39 | 78 | 24.56 | 150 | 10.85 | 4.72 | 4 | 9 |  |
| Scene | 45 | 82 | 21.91 | 150 | 11.46 | 8.34 | 4 | 9 |  |
| Hierarchy Planning | High-to-Mid | 76 | 598 | 1008.26 | 598 | 16.5 | 5.18 | 1 | 9 |
| Mid-to-Low | 76 | 598 | 1008.26 | 598 | 22.12 | 6.02 | 1 | 9 |  |
| Visual Grounding | Object | 41 | 88 | 119.05 | 220 | 22.60 | - | 1 | 25 |
| Frame | 65 | 147 | 139.57 | 368 | 23.01 | - | 1 | 25 |  |
| Temporal | 69 | 416 | 68.90 | 735 | 82.40 | - | 1 | 8 |  |
| Reward Modeling | Critique | 76 | 963 | 16.60 | 1236 | 11.21 | 11.00 | 1 | 9 |
| Feedback | 74 | 638 | 15.08 | 638 | 19.24 | 53.06 | 1 | 9 |  |

Video Question-Answering.
To construct this benchmark, we integrate Narration data, capturing interactions between the camera wearer and the environment, focusing on object, action, and scene.
We develop specific prompts, combined with the narrations, as inputs for GPT-4o tailored to each fine-grained dimension.
GPT-4o then generate diverse question-answering pairs for these dimensions.
Due to the noise in generated instances and the cost of API-based evaluation, three human annotators filter them to ensure quality and diversity, selecting the most representative examples.
Finally, we totally collect 600 instances with 50 examples per fine-grained dimensions.

Hierarchy Planning.
We use existing human annotations in Ego4D with goals-steps-substeps labels to construct our hierarchical data.
For video inputs, we use from 00:00 to the start time of the current step for both high-to-mid and mid-to-low subtasks.
In the high-to-mid task, high-level goals serve as inputs and corresponding mid-level step as labels.
Steps requiring numerous low-level actions and exceeding 180 seconds are decomposed into essential substeps.
Next, we use the ground-truth mid-level step and its Narration as potential low-level atomic actions.
To align with Embodied AI controller, GPT-4o converts narrations (e.g., “C cuts a mango with a knife”) into function calls (e.g., “cut(mango, knife)”) and merges semantically similar functions.
To ensure MLLMs understand the available low-level functions and their usage, we apply GPT-4o to generate their documentation.
After filtering by three annotators, we obtain 598 clipped videos and instances for both tasks, with the mid-to-low task comprising 74 atomic actions.

Visual Grounding.
Visual Queries in Ego4D includes queries about objects and their tracks in the video, represented as frames with bounding boxes.
We use these annotations to collect object grounding and frame grounding subtasks.
For object grounding, given a clipped video and its annotations, we select the video from the beginning to the last annotated frame.
We construct a prompt with the Narration in this segment for GPT-4o to generate a query.
The answer is the bounding box annotation of the object in the final frame.
In frame grounding, the video input spans from the start of the clipped video to either the “query_video_frame” annotated in Visual Queries or the end frame of the clip.
We prompt GPT-4o using the object name and narrations within the time segment to generate a specific description of the frames containing the object.
All annotated frames in the input video are considered the answer.
Considering that step-substep annotations in Goal-Step include temporal information, we primarily use these clipped videos.
By providing annotations and prompts to GPT-4o, we obtain a specific description of the selected sub-step as the query and the temporal interval of the sub-step as the answer. Finally, we obtain 369 instances for object and frame grounding, and 735 instances for temporal grounding.

Reward Modeling.
Our clipped videos in the hierarchy planning task contain entire mid-level steps, which we use to construct the reward modeling dataset.
We label the original complete videos as positive instances.
For negative instances, we employ two strategies:
(1) using GPT-4o to generate questions where the action is similar but different from the video content;
(2) manually crop each video clip to 60%–80% of its original length to ensure the action remains unfinished.
Each negative sample includes three feedback demonstrating the incomplete action.
Considering narrations often lack detailed descriptions to determine whether an action is complete, we employ FFmpeg(^*^**https://www.ffmpeg.org/) to extract keyframes from each clipped video.
Then, we use GPT-4o to generate feedback from different aspects for negative instances based on step annotations and the extracted keyframes. After filtering by three annotators, we obtain 963 and 638 instances for critique and feedback tasks.

## 5 Experiments

In this section, we mainly introduce our extensive adopted models, including API-based models, a series of open-source image-based and video-based MLLMs.
The prompts for both inference and evaluation are shown in Appendix A.
Furthermore, we summarize the experimental results for different tasks, and their corresponding case studies are illustrated in Appendix B.

### 5.1 Models

**Table 3: LM, VM, TM, AM refer to the language module, visual module, temporal module, and alignment module. CLIP-ViT-L is CLIP module pre-trained on LLaVA, while CLIP-ViT-G is the CLIP module pre-trained on LAION. TA Frame Encoder denotes Time-aware Frame Encoder.**
| Model | LM | VM | TM | AM | Model Size | Training Data |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Image/Video-Text | Instruction |  |  |  |  |  |  |
| Image-based MLLMs |  |  |  |  |  |  |  |
| mPLUG-Owl2 | LLaMA | CLIP-ViT-L | - | Visual Abstractor | 7B | 1.23M | - |
| Qwen-VL | Qwen | CLIP-ViT-G | - | VL Adapter | 7B | 1.4B | 350K |
| LLaVA-1.5 | LLaMA/Vicuna | CLIP-ViT-L-3 | - | Linear | 7B | 558K | 665K |
| LLaMA-Adapter v2 | LLaMA | CLIP-ViT-L | - | Linear | 7B | 567K | 52K |
| Video-based MLLMs |  |  |  |  |  |  |  |
| LWM | LLaMA2 | VQGAN | - | - | 7B | 1.01B | 519K |
| TimeChat | LLaMA2 | CLIP-ViT-G | TA Frame Encoder | Sliding Video Q-Former | 7B | - | 177K |
| GroundingGPT | Vicuna-v1.5 | CLIP-ViT-L | Position Encoding | MLP | 7B | >1.3M | >770K |
| InternVL2 | InternLM2.5 | InternViT-300M | - | QLLaMA | 8B | 10B | - |
| InternLM-XComposer2.5 | InternLM2 | CLIP-ViT-L | - | Partial-LoRA | 7B | - | - |
| Video-LLaVA | Vicuna-v1.5 | Language Bind | - | Linear | 7B | 1.26M | 765K |
| PG-Video-LLaVA | Vicuna-v1.5 | CLIP-ViT-L-3 | Grounding Module | MLP | 7B | - | 100K |
| mPLUG-Owl3 | Qwen2 | SigLip-400M | MI-RoPE | Linear | 8B | >1.7M | >1M |
| MiniCPM-V2.6 | Qwen2 | SigLip-400M | - | Adaptive Visual Encoding | 8B | 570M | 3M |
| Qwen2-VL | Qwen2 | ViT | M-RoPE | 3D-conv | 8B | 1.4T${}_{\text{tokens}}$ | - |

API-based Models.
We conduct experiments with the representative GPT-4o (2024-05-13).
Since GPT-4o does not support video input, we address this limitation and enhance methodological diversity with the following assessment scheme: (1) w/ 32 frames: Select 32 keyframes based on the video context; (2) w/ 8 frames: Select 8 keyframes with the same input format as most open-source MLLMs; (3) w/ captions: Replace 32 keyframes with its corresponding captions generated by GPT-4o; (4) w/ only-qa: Input only the question without any frames or captions.

#### Open-Source Image-based MLLMs.

We select several image-based MLLMs that demonstrated strong performance in EgoThink (Cheng et al., ).
Below, we provide a brief introduction and present their detailed component information in Table 3.

- •
mPLUG-Owl2 (Ye et al., ) integrates shared functional modules to promote modality collaboration and includes a modality-adaptive module to preserve modality-specific features.
- •
Qwen-VL-Chat (Bai et al., ) employs a single-layer cross-attention with random initialization, trained with approximately 1.5 billion image-text pairs, and aligns with human interaction.
- •
LLaVA-1.5 (Liu et al., ) utilizes academic task data and replaces the linear visual language connector with a two-layer MLP connector.
- •
LLaMA-Adapter V2 (Gao et al., ) proposes an early fusion strategy that effectively adapts LLaMA (Touvron et al., ) to visual instruction models.

#### Open-Source Video-based MLLMs.

We comprehensively select the most popular and high-performance video-based MLLMs to evaluate. Our video-based MLLMs include a series of general models and three grounding-specific models. The detailed components are shown in Table 3.

- •
LWM (Liu et al., ) uses Blockwise RingAttention and masked sequence packing to manage long video and language sequences, enabling training on contexts up to 1 million tokens for better multimodal understanding.
- •
TimeChat (Ren et al., ) is a time-sensitive multimodal large language model that aligns visual information with specific time frames. It utilizes a sliding video Q-Former to adapt to videos of varying lengths.
- •
GroundingGPT (Li et al., ) effectively enhances the understanding and grounding of fine-grained image, video, and audio modalities through a three-stage, coarse-to-fine training strategy.
- •
InternVL2 (Chen et al., ) builds on InternVL’s QLLaMA progressive alignment strategy. It optimizes vision-language alignment while scaling up the language model in stages, starting small and expanding gradually, with data refined from coarse to fine.
- •
InternLM-XComposer-2.5 (Zhang et al., ) introduces RoPE extrapolation for long-context handling, ultra-high resolution understanding, fine-grained video comprehension, and multi-turn multi-image dialogue, and extra LoRA parameters for advanced text-image composition.
- •
Video-LLaVA (Lin et al., ) proposes a unified visual representation method that aligns images and videos within the language feature space. This approach enhances multimodal interactions and leverages a mixed dataset of images and videos to mutually improve each modality.
- •
PG-Video-LLaVA (Munasinghe et al., ) is a video-based MLLM with pixel-level grounding capabilities. It can also integrate audio to enhance video understanding. Additionally, its modular design enhances flexibility.
- •
mPLUG-Owl3 (Ye et al., ) introduces hyper attention blocks to efficiently integrate vision and language into a shared semantic space, improving long image sequence processing.
- •
MiniCPM-V-2.6 (Yao et al., ) utilizes the adaptive visual encoding mechanism of LLaVA-UHD (Xu et al., ) and various end-side optimizations to compress the multimodal model.
- •
Qwen2-VL (Bai et al., ; team, ) has been upgraded with Naive Dynamic Resolution and Multimodal Rotary Position Embedding (M-ROPE) technologies, improving its multimodal data processing and understanding capabilities.

**Table 4: Experimental results of video question answering. OE, OO, OI, OC, OS, OP denote object existence, object order, object interaction, object count, object state, object prediction. AE, AS, AC indicates action existence, action sequence, action count. SE, ST, SP denote scene existence, scene transition, scene prediction. The bold font denotes the best performance and the underline font denotes the second-best performance.**
| Models | Object | Action | Scene | Average |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| OE | OO | OI | OC | OS | OP | AE | AS | AC | SE | ST | SP |  |  |
| GPT-4o w/ only-qa | 13.00 | 00.00 | 12.00 | 06.00 | 31.00 | 23.00 | 25.00 | 04.00 | 02.00 | 18.00 | 06.00 | 20.00 | 13.33 |
| GPT-4o w/ captions | 51.00 | 16.00 | 14.00 | 30.00 | 25.00 | 44.00 | 34.00 | 05.00 | 22.00 | 42.00 | 28.00 | 16.00 | 27.25 |
| GPT-4o w/ 8 frames | 51.00 | 16.00 | 30.00 | 33.00 | 35.00 | 45.00 | 38.00 | 25.00 | 22.00 | 43.00 | 23.00 | 24.00 | 32.83 |
| GPT-4o w/ 32 frames | 52.00 | 18.00 | 30.00 | 35.00 | 32.00 | 40.00 | 39.00 | 20.00 | 24.00 | 46.00 | 20.00 | 18.00 | 31.17 |
| mPLUG-Owl2-llama2-7B | 29.00 | 06.00 | 15.00 | 30.00 | 10.00 | 16.00 | 28.00 | 08.00 | 28.00 | 20.00 | 10.00 | 06.00 | 17.17 |
| Qwen-VL-7B-Chat | 41.00 | 07.00 | 13.00 | 33.00 | 14.00 | 30.00 | 17.00 | 03.00 | 27.00 | 16.00 | 13.00 | 10.00 | 18.67 |
| LLaVA-1.5-7B | 46.00 | 07.00 | 17.00 | 34.00 | 22.00 | 24.00 | 25.00 | 01.00 | 14.00 | 20.00 | 13.00 | 16.00 | 19.92 |
| LLaMA-Adapter-V2-7B | 48.00 | 05.00 | 26.00 | 17.00 | 19.00 | 39.00 | 14.00 | 09.00 | 35.00 | 24.00 | 10.00 | 16.00 | 21.80 |
| LWM-Chat-32k-Jax-7B | 42.00 | 03.00 | 20.00 | 12.00 | 10.00 | 11.00 | 20.00 | 04.00 | 21.00 | 27.00 | 09.00 | 05.00 | 15.33 |
| TimeChat-7B | 42.00 | 05.00 | 15.00 | 21.00 | 11.00 | 23.00 | 20.00 | 04.00 | 20.00 | 31.00 | 14.00 | 14.00 | 18.33 |
| GroundingGPT-7B | 43.00 | 03.00 | 20.00 | 30.00 | 10.00 | 23.00 | 22.00 | 04.00 | 32.00 | 23.00 | 19.00 | 14.00 | 20.25 |
| InternVL2-8B | 43.00 | 16.00 | 21.00 | 18.00 | 20.00 | 27.00 | 19.00 | 04.00 | 15.00 | 37.00 | 17.00 | 12.00 | 20.75 |
| InternLM-XComposer2.5-7B | 36.00 | 06.00 | 24.00 | 22.00 | 19.00 | 34.00 | 30.00 | 02.00 | 30.00 | 31.00 | 11.00 | 12.00 | 21.42 |
| Video-LLaVA-7B | 44.00 | 08.00 | 19.00 | 34.00 | 15.00 | 30.00 | 18.00 | 03.00 | 38.00 | 28.00 | 11.00 | 11.00 | 21.58 |
| PG-Video-LLaVA-7B | 49.00 | 05.00 | 21.00 | 15.00 | 23.00 | 37.00 | 25.00 | 03.00 | 16.00 | 35.00 | 18.00 | 20.00 | 22.25 |
| mPLUG-Owl3-7B | 32.00 | 07.00 | 26.00 | 13.00 | 33.00 | 34.00 | 18.00 | 06.00 | 36.00 | 37.00 | 23.00 | 10.00 | 22.92 |
| MiniCPM-V-2.6-8B | 48.00 | 12.00 | 28.00 | 16.00 | 25.00 | 42.00 | 31.00 | 11.00 | 15.00 | 42.00 | 23.00 | 18.00 | 25.92 |
| Qwen2-VL-7B-Instruct | 36.00 | 19.00 | 28.00 | 28.00 | 28.00 | 43.00 | 24.00 | 09.00 | 20.00 | 48.00 | 24.00 | 20.00 | 27.25 |

### 5.2 Results

Video Question-Answering.
The results of the video question-answering task are shown in Table 4 and Table 5.
MLLMs perform poorly, with a best average accuracy of 32.82% across all dimensions (35.00% for object, 28.33% for action, and 26.33% for scene elements), indicating struggles with egocentric video question-answering.
GPT-4o with 8 frames performs better than with 32 frames but still underperforms compared to some open-source video MLLMs in certain dimensions.
Two probable reasons are: (1) GPT-4o’s sensitivity to privacy policies for indoor videos, causing it to refuse more questions given more images; (2) insufficient information from extracted keyframes.
GPT-4o with captions sometimes matches or surpasses the 8 or 32-frame setups in scene transitions, but performs poorly in object interaction and action sequence dimensions, indicating that captions provide sufficient high-level abstraction but lack detailed low-level action information.
We regard the GPT-4o with only-qa as a baseline to demonstrate state-of-the-art performance using only question-answering pairs without any vision information. All other MLLMs perform better than the average accuracy of GPT-4o with only-qa, showing that our benchmark indeed requires vision information to solve these problems.
Open-source video-based MLLMs generally surpass image-based MLLMs, highlighting the need for full video information, especially in dynamic dimensions.
Among these, Qwen2-VL-7B-Instruct achieves the best performance, even surpassing GPT-4o in two dimensions and achieving the second-best performance in three dimensions.

Hierarchy Planning.
The hierarchy planning results are shown in Table 5, with the average video duration being 1008.26 seconds.
In the High-to-Mid task, GPT-4o series models and image-based MLLMs, which process multiple or single images, lack sufficient information to determine the entire progress and predict the next step.
Hence, increasing the total number of frames significantly improves performance.
For video-based models, the best performance of MiniCPM is comparable to the state-of-the-art performance of GPT-4o with 32 frames but still performs poorly, indicating significant room for improvement.
For the Mid-to-Low task, the most notable phenomenon is that GPT-4o series models significantly outperform open-source MLLMs, which achieve about 0.05 accuracy.
The main reason behind this phenomenon is the limited long-context capability and instruction-following capability of open-source MLLMs.
We can only provide them with a compressed function document, and they often do not generate answers following the output format.

Visual Grounding.
Visual grounding tasks involve identifying specific objects, frames, or temporal segments within a video. API-based and image-based MLLMs abandon this information after extracting keyframes, necessitating the use of open-source video-based MLLMs for performance assessment.
Due to the new design of object and frame grounding tasks, these MLLMs are not yet optimized for these formats, leading to generally poor performance.
It is understandable that object grounding in a single image remains a challenging task for MLLMs, even more so within a video context.
For temporal grounding, some MLLMs especially trained for this task achieve relatively high scores, with PG-Video-LLaVA scoring 16.18.
Surprisingly, MiniCPM performs well across all grounding dimensions, despite not being specially trained for these tasks.
Although the performances of MLLMs are poor, we believe these tasks have a significant impact on downstream tasks in Embodied AI and deserve more attention.

Reward Modeling.
As shown in Table 5, the critique task is a binary classification task with a random guess baseline of 50%. Therefore, the overall performance of MLLMs is suboptimal, with the best accuracy reaching only 59.39%, indicating that MLLMs struggle to determine whether a task has been completed.
For the feedback task, GPT-4o with 8 frames (33.46%) and 32 frames (34.64%) significantly outperforms the best results from other API-based methods (14.58%) and open-source MLLMs (13.09%).
This demonstrates that generating feedback requires more fine-grained visual information not present in captions and superior reasoning capability.

**Table 5: Experimental results of video question answerng, hierarchy planning, visual grounding, and reward modeling tasks. The bold font denotes the best performance and the underline font denotes the second-best performance.**
| Models | Video Question Answering | Hierarchy Planning | Visual Grounding | Reward Modeling |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Object | Action | Scene | High-to-Mid | Mid-to-Low | Object | Frame | Temporal | Critique | Feedback |  |
| GPT-4o w/ only-qa | 14.17 | 10.33 | 14.67 | 08.86 | 32.56 | - | - | - | 48.46 | 06.81 |
| GPT-4o w/ captions | 30.00 | 20.33 | 28.67 | 09.53 | 33.65 | - | - | - | 58.82 | 14.58 |
| GPT-4o w/ 8 frames | 35.00 | 28.33 | 30.00 | 12.04 | 35.47 | - | - | - | 58.74 | 33.46 |
| GPT-4o w/ 32 frames | 34.50 | 27.67 | 26.33 | 14.97 | 35.08 | - | - | - | 59.39 | 34.64 |
| mPLUG-Owl2-llama2-7B | 17.67 | 21.33 | 12.00 | 05.77 | 00.00 | - | - | - | 41.26 | 01.56 |
| Qwen-VL-7B-Chat | 23.00 | 15.67 | 13.00 | 10.79 | 00.04 | - | - | - | 49.19 | 04.08 |
| LLaVA-1.5-7B | 25.00 | 13.33 | 16.33 | 02.59 | 00.01 | - | - | - | 53.72 | 03.53 |
| LLaMA-Adapter-V2-7B | 25.67 | 19.33 | 16.67 | 04.59 | 00.03 | - | - | - | 39.64 | 02.89 |
| LWM-Chat-32k-Jax-7B | 16.33 | 15.00 | 13.67 | 01.33 | 00.00 | 00.00 | 00.00 | 00.00 | 22.09 | 00.00 |
| TimeChat-7B | 19.50 | 14.67 | 19.67 | 03.85 | 00.01 | 00.00 | 00.00 | 14.56 | 47.25 | 00.57 |
| GroundingGPT-7B | 21.50 | 19.33 | 18.66 | 05.69 | 00.05 | 00.76 | 00.54 | 00.44 | 51.13 | 02.19 |
| InternVL2-8B | 24.17 | 12.67 | 22.00 | 03.34 | 00.05 | 00.09 | 00.00 | 06.87 | 52.67 | 00.71 |
| InternLM-XComposer2.5-7B | 23.50 | 20.67 | 18.00 | 09.62 | 00.04 | 00.00 | 00.54 | 03.50 | 51.41 | 08.23 |
| PG-Video-LLaVA-7B | 25.00 | 14.67 | 24.33 | 05.35 | 00.00 | 00.08 | 00.00 | 16.18 | 48.30 | 06.27 |
| mPLUG-Owl3-7B | 24.17 | 20.00 | 23.33 | 12.29 | 00.03 | 00.00 | 00.00 | 00.00 | 50.00 | 09.09 |
| MiniCPM-V-2.6-8B | 28.50 | 19.00 | 27.67 | 14.13 | 00.06 | 00.35 | 01.63 | 11.30 | 51.54 | 13.09 |
| Qwen2-VL-7B-Instruct | 30.33 | 16.00 | 27.67 | 09.88 | 00.00 | 00.00 | 00.00 | 00.00 | 49.03 | 04.62 |

## 6 Conclusion

In this paper, we introduce VidEgoThink, a comprehensive benchmark designed to evaluate egocentric video understanding across four critical functions in Embodied AI.
Our assessment of popular API-based and open-source MLLMs reveals that these models still face significant challenges in processing egocentric videos.
Although GPT series models perform relatively better, they exhibit notable deficiencies in certain areas, highlighting the need for further improvements and optimizations.
VidEgoThink underscores the limitations of current MLLMs in handling first-person perspective data, thereby indicating directions for future research and advancements

Limitations.
VidEgoThink is the first to propose four tasks for assessing egocentric video understanding in MLLMs for Embodied AI.
However, it has limited data diversity and immature evaluation methods, particularly in hierarchy planning and reward modeling.
Future work should improve these aspects and address the high costs of human annotation and API-based evaluations, which limit the number of question-answer pairs.
We plan to expand the benchmark and develop egocentric foundation models for robotics.

Broader Impacts.
Two key areas for the future of Embodied AI are egocentric video and multi-modal large language models.
On the one hand, our real world cannot be mapped to virtual simulators exactly the same way.
Real-world environments cannot be exactly replicated in virtual simulators, making egocentric video a preferred method for collecting action data, especially with the rise of smart glasses and humanoid robots.
Learning from egocentric video is crucial for future advancements.
Although end-to-end MLLMs for Embodied AI are still an open research question, we believe a hierarchical system that uses vision-language models for perception and cognition is an emerging paradigm. Ideal foundation models should function in the real world, capable of thinking, understanding, and interacting like humans.

## Appendix A Prompt Hubs

To address concerns about potential data breaches through prompts, here we only release the detailed prompts for each task to facilitate inference and evaluation.

### A.1 Model Inference Prompts

As an example, we list the general prompts for 8 frames, 32 frames and open-source MLLMs.
The inference type of “caption” for GPT series models will add a prompt “Here is the captions of the video: {caption}.” after the sentence “Imagine you are the camera wearer (I) who recorded the video”.
For the inference type of “only-qa”, we delete the prompt “Imagine you are the camera wearer (I) who recorded the video”.

- •
Video Question Answering: Imagine you are the camera wearer (I) who recorded the video. Please directly answer the question as short as possible. Question: {question} Short answer:
- •
High-to-Mid in Hierarchy Planning: Imagine you are the camera wearer (I) who recorded the video. Given the high-level goal (e.g., ’making dumpling’) and the current progress video, you need to predict the next mid-level step (e.g., fold dumplings on a cutting board) to achieve the goal. Please directly generate the next one step as short as possible. Question: {question} Short answer:
- •
Mid-to-Low in Hierarchy Planning: Imagine you are the camera wearer (I) who recorded the video. Here are a set of actionable functions below.
[begin of actionable function and documentation]
{‘put’: ‘put(<arg1>, <arg2>) is used to place an object at a specified or default location. <arg1>refers to the item to be placed, whereas <arg2>is optional and specifies the location where the item should be placed. If <arg2>is omitted, the item is placed in a generic, predefined area.’,
‘grab’: ‘grab(<arg1>, <arg2>) is used to simulate the action of grasping or picking up objects, especially in a kitchen setting. <arg1>refers to the primary object to be grabbed, while <arg2>is optional and denotes an associated tool or container that aids in handling or processing the primary object.’,
‘talk’: ‘talk(<arg1>, <arg2>) is used to simulate a conversation scenario with specific entities. <arg1>is mandatory and specifies the primary entity involved in the conversation, such as a ’woman’, ’man’, or ’person’. <arg2>is optional and typically represents a secondary entity or context within the conversation, providing additional detail or focus.’,
‘close’: ‘close(<arg1>, <arg2>) is used to encapsulate or seal an item, either partially or completely. <arg1>refers to the object to be closed or covered, and <arg2>is optional, describing the material or object used for closing or covering <arg1>. If <arg2>is omitted, the closing is done without any specified covering.’,
‘adjust’: ‘adjust(<arg1>, <arg2>) is used to modify the position or settings of objects or items. <arg1>is mandatory and specifies the primary object to adjust, while <arg2>is optional and used for adjustments involving a specific secondary object or location relative to the first.’,
‘arrange’: ‘arrange(<arg1>, <arg2>) is used to organize objects systematically within a predefined space. <arg1>refers to the items to be arranged, while <arg2>is optional and specifies the area or container where these items will be organized. If <arg2>is omitted, the items are arranged in a default designated space.’,
‘open’: ‘open(<arg1>, <arg2>) is used to manipulate the state of various containers or coverings by opening them. <arg1>refers to the primary object or container that needs to be opened, like a ’pot’ or ’drawer’. <arg2>is optional and specifies a secondary descriptor or specific part of the primary object, like ’top’ or ’front’, indicating a particular method or area of opening.’,
‘walk’: ‘walk(<arg1>, <arg2>) is used to move an entity towards a specified location within an environment. <arg1>refers to the primary location or object the entity should head towards, and <arg2>refers to optional additional parameters that provide extra directional or contextual details to refine the movement.’,
‘empty’: ’empty(<arg1>, <arg2>) is used to transfer a specified item from one holding medium to another specified container. <arg1>refers to the item being transferred, while <arg2>is the destination container where the item is moved to.’,
‘move’: ’move(<arg1>, <arg2>) is used to transfer items from one place to another. <arg1>refers to the item that is being moved. <arg2>is optional and specifies where the item should be placed; if omitted, it indicates the item is moved without a specific destination in mind, likely for clearing space or as an intermediate step.’,
‘push’: ’push(<arg1>, <arg2>) is used to initiate a push action on various objects or elements. <arg1>refers to the main object or element to be pushed, and <arg2>is optional and used to specify a particular part or aspect of <arg1>for a more precise push action.’,
‘clean’: ’clean(<arg1>, <arg2>) is used to cleanse various items, which may include food or non-food objects. <arg1>refers to the primary item that requires cleaning, while <arg2>is optional and specifies additional items or the context like the cleaning environment or method. If <arg2>is omitted, the function adapts its operation to effectively clean <arg1>alone.’,
‘rotate’: ‘rotate(<arg1>, <arg2>) is used to turn or move an item, typically in a culinary context. <arg1>refers to the item that needs to be rotated. <arg2>is optional and describes the utensil or tool used to facilitate the rotation. If <arg2>is omitted, the item is rotated manually or with a default method.’,
‘serve’: “serve(<arg1>, <arg2>) is used to manage the distribution or placement of items. <arg1>refers to the item to be served or used, and <arg2>is optional, indicating the person or the hand (right or left) that will handle the item. If <arg2>is omitted, the item is handled by default means.’,
‘shell’: ’shell(<arg1>, <arg2>) is used to remove the outer covering from items, typically food-related like seeds, vegetables, and fruits. <arg1>is mandatory and specifies the item from which the shell or outer layer needs removal. <arg2>is optional and indicates any tool that might assist in the shelling process, such as a knife or fork. If <arg2>is omitted, the item is shelled using standard methods.’,
‘turn_on’: ‘turn_on(<arg1>, <arg2>, etc) is used to activate one or multiple household or industrial appliances. <arg1>is mandatory and refers to the primary appliance that needs to be activated. <arg2>, etc, represent additional appliances that can be optionally activated simultaneously.’,
‘turn_off’: ‘turn_off(<arg1>) is used to deactivate various devices or utilities. <arg1>refers to the object or device to be deactivated, such as a ’socket’, ’tap’, or ’blending machine’.’,
‘cut’: ‘cut(<arg1>, <arg2>) is used to perform the action of cutting on various items. <arg1>refers to the item to be cut, which is mandatory. <arg2>is optional and denotes the tool used for cutting; if <arg2>is omitted, a standard cutting tool is assumed.’,
‘throw’: ‘throw(<arg1>, <arg2>) is used to dispose of or place an object in a specified or default location. <arg1>refers to the item to be disposed of or relocated, whereas <arg2>is optional and designates the location where the item should be placed. If <arg2>is omitted, the function selects a default disposal method or location based on the item or context.’,
‘mix’: ‘mix(<arg1>, <arg2>) is used to combine or stir ingredients, typically in a cooking context. <arg1>refers to the item or ingredients to be mixed, and <arg2>is optional and denotes the tool used for mixing, such as a spoon or paddle. When <arg2>is omitted, the method of mixing is unspecified or assumed to be manual.’,
‘touch’: ‘touch(<arg1>, <arg2>) is used to simulate the action of touching various items or materials. <arg1>refers to the object or material that is the primary focus of the action, whereas <arg2>is optional and provides additional detail on a specific part of the item to touch, assuming a generic aspect if omitted.’,
‘eat’: ‘eat(<arg1>, <arg2>) is used to perform the action of consuming a specified item. <arg1>refers to the item to be consumed. <arg2>is optional and describes the method by which the food is to be eaten, for example, ’slowly’.’,
‘pull’: ‘pull(<arg1>, <arg2>) is used to simulate the action of pulling something within a specific context. <arg1>refers to the object that is being pulled, such as a drawer or an oven grill. <arg2>is optional and describes a secondary reference or location, like a pan or a steel cabinet, which adds context to where the object is located or what it is associated with. If <arg2>is omitted, the action focuses solely on <arg1>.’,
‘unfold’: ‘unfold(<arg1>, <arg2>=None) is used to expand or open various types of items. <arg1>refers to the item to be unfolded, such as fabric, body parts, or food items. <arg2>is optional and allows for additional specifications on how the unfolding should be performed, tailored based on the nature of the item. If <arg2>is omitted, basic operations are performed.’,
‘dip’: ‘dip(<arg1>, <arg2>) is used to immerse an item into a container. <arg1>refers to the item to be dipped, such as ’dough’ or ’hand’, and <arg2>describes the container like ’bowl of water’ or ’flour’. This function facilitates operations involving coating or soaking an item.’,
‘observe’: ‘observe(<arg1>) is used to examine the specified environment or objects. <arg1>refers to an array containing one or more strings that describe what should be focused on during the observation. At least one string is mandatory to define the scope of observation, while additional strings are optional to provide more detail.’,
‘taste’: ‘taste(<arg1>, <arg2>) is used to simulate the action of tasting a specified item with or without a utensil. <arg1>refers to what is being tasted, such as food or soup. <arg2>is optional and specifies the utensil used for tasting, like a spoon. If <arg2>is omitted, the action of tasting is assumed to be done without any specific utensil.’,
‘apply’: ‘apply(<arg1>, <arg2>) is used to perform operations involving the application or manipulation of cooking ingredients or tools. <arg1>refers to the primary material or tool being used, such as ’flour’ or ’oil’. <arg2>is optional and typically refers to the target where <arg1>is applied, like ’dough’ or ’frying pan’.’,
‘switch’: ‘switch(<arg1>) is used to change or replace the current tool in use within a system or application. <arg1>corresponds to the name of the tool that the function will switch to.’,
‘roll’: ‘roll(<arg1>, <arg2>) is used to flatten or shape an item using a tool. <arg1>refers to the item to be rolled, such as dough or foil. <arg2>is optional and indicates the tool used for rolling, like a ’rolling pin’ or ’rolling board’. If <arg2>is not specified, a default tool or method is used to roll <arg1>.’,
‘lay’: ‘lay(<arg1>, <arg2>) is used to place objects or substances within a specific environment or a default setting if not specified. <arg1>refers to what is being placed, and <arg2>is optional and defines where the item is placed.’,
‘gesture’: ‘gesture(<arg1>, <arg2>, etc) is used to perform low-level actions based on the type of gesture or action specified. <arg1>is mandatory and refers to the string specifying the type of gesture or action to be executed. <arg2>is optional and allows for additional details or modifications to the gesture when necessary.’,
‘steer’: ‘steer(<arg1>, <arg2>, etc) is used to manipulate or interact with an object in a controlled environment. <arg1>refers to any object that requires handling or operation. <arg2>is optional, enhancing or specifying the nature of the interaction.’,
‘operate’: ‘operate(<arg1>, <arg2>) is used to activate or manage a specified device. <arg1>refers to the name of the device being operated, while <arg2>is optional and allows specific operational parameters to be passed, such as temperature, duration, or intensity.’,
‘store’: ‘store(<arg1>, <arg2>) is used to log or record items into a storage system. <arg1>refers to the list of items to be stored, which can include a single item or multiple items listed together. <arg2>is optional and specifies where the items are to be stored, indicating the physical or logical grouping.’,
‘tilt’: ‘tilt(<arg1>, <arg2>) is used to tip or angle an item, often to enable actions like pouring. <arg1>refers to the item that needs to be tilted. <arg2>is optional and defines the degree or direction of tilt. If <arg2>is omitted, a default tilt setting is used.’,
‘lift’: ‘lift(<arg1>, <arg2>) is used to simulate the action of picking up or lifting an object or a group of objects. <arg1>refers to the primary object to be lifted, and <arg2>is optional, indicating an additional item or tool used alongside the primary object during the lifting process.’,
‘scrape’: ‘scrape(<arg1>, <arg2>) is used to perform the action of scraping one item against another. <arg1>refers to the item to be scraped, which is mandatory, such as ’cabbage’ or ’vegetables’. <arg2>is optional and refers to the surface or tool against which the item is scraped, like ’board’ or ’frying pan’. If <arg2>is omitted, the function defaults to a generic, predefined scraping context.’,
‘bend’: ‘bend(<arg1>, <arg2>, <arg3>) is used to modify the shape or structure of an object. <arg1>refers to the object undergoing the bending. <arg2>and <arg3>are optional and specify the degree and the direction of the bend, respectively, allowing for precise control over the bending process.’,
‘hit’: ‘hit(<arg1>, <arg2>) is used to simulate the action of one object striking another. <arg1>refers to the primary object being hit, while <arg2>is optional and indicates any additional object used in the hitting action, such as a tool.’,
‘reduce_heat’: ‘reduce_heat(<arg1>, <arg2>) is used to lower the temperature or heat output of a specific device. <arg1>refers to the device on which the heat reduction is to be applied, and <arg2>is optional and provides an interface or method for achieving the heat reduction, allowing for precise control when specified.’,
‘rub’: ‘rub(<arg1>, <arg2>) is used to simulate the action of rubbing an object or surface. <arg1>refers to the primary object that is being rubbed, and <arg2>is optional, referring to a secondary object or surface involved in the rubbing, which can enhance or alter the rubbing context. If <arg2>is omitted, the rubbing action is considered to be performed solely with <arg1>.’,
‘add’: ‘add(<arg1>, <arg2>) is used to simulate placing an item into a container or context within a simulated environment. <arg1>refers to the object to be added, which is mandatory. <arg2>is optional and specifies the location or receptacle for the item. If <arg2>is omitted, the item is added to a default location or context.’,
‘mould’: ‘mould(<arg1>) is used to shape or form a material into a desired structure. <arg1>refers to the substance that needs to be shaped, such as clay, dough, or plastic.’,
‘knead’: ‘knead(<arg1>, <arg2>) is used to manipulate and prepare materials. <arg1>refers to the primary material to be kneaded, such as dough or clay. <arg2>is optional and denotes the surface or item against which the kneading is performed, like a tray or a rolling board.’,
‘stop’: ‘stop(<arg1>, <arg2>) is used to terminate an ongoing process. <arg1>refers to the type of process being stopped, such as ’liquid’. <arg2>is optional and specifies the equipment involved, like ’gas cooker’. If <arg2>is not provided, the function defaults to stopping all processes related to <arg1>.’,
‘cook’: ‘cook(<arg1>, <arg2>) is used to simulate the cooking process of a specified ingredient with or without a utensil. <arg1>refers to the item to be cooked, which is a mandatory argument. <arg2>is optional and specifies the tool used in the cooking process, defaulting to none if not provided.’,
‘rest’: ‘rest(<arg1>, <arg2>) is used to model the passive placement of one object against or on another. <arg1>refers to the primary object that is being supported or placed, while <arg2>is optional and refers to the object or surface against which <arg1>is resting. If <arg2>is omitted, the function defaults to a predetermined resting position or surface.’,
‘increase_temperature’: ‘increase_temperature(<arg1>, <arg2>) is used to raise the temperature of a device using a control mechanism. <arg1>refers to the device whose temperature needs to be increased, such as a cooker or heater. <arg2>is optional and refers to the specific method or interface, like a control knob or button, used to increase the temperature; if not specified, a default method is used.’,
‘dab’: ‘dab(<arg1>, <arg2>) is used to absorb or blot excess liquid or substances from items. <arg1>refers to the object that requires dabbing, while <arg2>is optional and specifies the material used for dabbing. If <arg2>is omitted, a standard method of dabbing is applied.’,
‘fix’: ‘fix(<arg1>, <arg2>) is used to attach or affix <arg1>to <arg2>. <arg1>refers to the object or component that needs to be fixed, while <arg2>is optional and identifies the target object or location to which <arg1>will be attached. If <arg2>is omitted, <arg1>is attached to a default object or location.’,
‘dry’: ‘dry(<arg1>, <arg2>) is used to remove moisture from specified items. <arg1>refers to the item needing drying, like ”hands” or ”mango.” <arg2>is optional and indicates the material used to aid the drying, such as ”towel” or ”napkin.”’,
‘hang’: ‘hang(<arg1>, <arg2>) is used to place an object onto a specified or default location for storage or accessibility. <arg1>refers to the object to be hung, and <arg2>is optional and denotes the location where the object should be placed. If <arg2>is omitted, a default location is used.’,
‘tie’: ‘tie(<arg1>, <arg2>) is used to wrap or secure items. <arg1>refers to the material used for tying, such as strings or wraps. <arg2>is optional and indicates additional materials or conditions that might affect the tying process, such as environmental factors or secondary materials.’,
‘sprinkle’: ‘sprinkle(<arg1>, <arg2>) is used to apply a substance over a surface or object. <arg1>refers to the material to be sprinkled, which is mandatory. <arg2>is optional and defines the surface or object where <arg1>is to be applied. If <arg2>is omitted, the substance is applied to a default location.’,
‘swing’: ‘swing(<arg1>) is used to alter or move an object in a predefined manner. <arg1>refers to the object being manipulated and the specific actions depend on the nature of this object.’,
‘fill’: ‘fill(<arg1>, <arg2>) is used to insert a specified substance into a designated container. <arg1>refers to the container that will contain the substance, and <arg2>describes the substance to be filled into the container.’,
‘wear’: ‘wear(<arg1>, <arg2>, <arg3>) is used to simulate the action of dressing a character or entity with a specific item. <arg1>is mandatory and refers to the item to be worn, described as a string. <arg2>and <arg3>are optional, allowing for customization of style and size, respectively.’,
‘unsure’: ‘unsure(<arg1>, <arg2>, etc) is used to perform an ambiguous action based on the provided context or data. <arg1>is a mandatory parameter that provides the necessary context or data for the operation of the function. <arg2>and other additional arguments are optional and enhance the function’s flexibility and adaptability to varying use cases.’,
‘sort’: ‘sort(<arg1>, <arg2>) is used to organize or prioritize items based on specific criteria. <arg1>is mandatory and specifies the operation to be performed, while <arg2>is optional and includes the items to be sorted. This function can be used with varying numbers of arguments to adapt to different sorting requirements or settings.’,
‘stretch’: ‘stretch(<arg1>) is used to modify the physical state of a malleable material by elongating or thinning it. <arg1>refers to the malleable material that is altered by the function.’,
‘squeeze’: ‘squeeze(<arg1>, <arg2>, etc) is used to compress or reduce the size of various types of input objects. <arg1>refers to the object or substance to be compressed. <arg2>and other optional arguments can be added to modify the function based on the specifics of the compression or the context in which it is applied.’,
‘flatten’: ‘flatten(<arg1>, <arg2>) is used to press and spread a material into a flatter shape. <arg1>is mandatory and specifies the material to be flattened, while <arg2>is optional and represents a tool used to assist in the flattening process. This function is generally used when a uniform thickness is desired or to prepare the material for further processing.’,
‘climb’: ‘climb(<arg1>) is used to simulate or command an entity to ascend or mount a specified target. <arg1>refers to the object or location that the entity should climb onto.’,
‘interact’: ‘interact(<arg1>, <arg2>) is used to perform interactions with various entities or objects. <arg1>refers to the entity or object to interact with, which is mandatory. <arg2>is optional and specifies the method or type of interaction desired; if omitted, it defaults to a standard interaction mode.’}
[end of actionable function and documentation]
Based on the low-level actionable actions provided, you will need to make one or more function calls in order to achieve the mid-level step described in the question.
Respond needs to strictly be a list of these actionable functions following this format: “fuction1(args)”,“fuction2(args)”,“fuction3(args)”, …
Besides these functions, your response should not contain anything else,these functions should not be numbered or explained, simply separated by commas and output directly.
For example: “put(jar, cabinet)”,“grab(jar)”,“mix(jar)”,“put(jar, cabinet)”.
You should not include any other text in your response.
Question: {question}
List of actionable functions:
- •
Object grounding in visual grounding: {question} Please give out the bounding box coordinates of the object.
- •
Frame grounding in visual grounding: {question} Analyze the provided video and identify the frame number of the last keyframe that is relevant to the specified query. Please provide only the frame number as your response.
- •
Temporal grounding in visual grounding:
{question} Please provide the starting and ending times for that step.
- •
Critique in reward modeling: Imagine you are the camera wearer (I) who recorded the video. Please directly answer yes or no to determin whether the task is completed or not. Question: {question} Short answer:
- •
Feedback in reward modeling: Imagine you are the camera wearer (I) who recorded the video. The video contains an uncompleted task. Please identify the essential completion signals in my observations that indicate the task is not completed by me. Please directly generate the rationale as short as possible. Question: {question} Short Answer:

### A.2 Evaluation Prompts

Here we list the prompts for API-based models to assess the performance for some tasks.

- •
Video question answering: [Instruction]\nPlease act as an impartial judge and evaluate the quality of the response provided by an AI assistant to the user question displayed below. Your evaluation should consider correctness and helpfulness. You will be given a reference answer and the assistant’s answer. Begin your evaluation by comparing the assistant’s answer with the reference answer. Identify and correct any mistakes. The assistant has access to an image alongwith questions but you will not be given images. Therefore, please consider only how the answer is close to the reference answer. If the assistant’s answer is not exactly same as or similar to the answer, then he must be wrong. Be as objective as possible. Discourage uninformative answers. Also, equally treat short and long answers and focus on the correctness of answers. After providing your explanation, you must rate the response with either 0, 0.5 or 1 by strictly following this format:“[[rating]]”, for example: “Rating: [[0.5]]”.\n\n[Question]\n{question}\n\n[The Start of Reference Answer]\n{ref_answer_1}\n[The End of Reference Answer]\n\n[The Start of Assistant’s Answer]\n{answer}\n[The End of Assistant’s Answer]”
- •
High-to-mid in hierarchy planning: [Instruction]\nPlease act as an impartial judge and evaluate the quality of the response provided by an AI assistant to the user question displayed below. Your evaluation should consider correctness and helpfulness. You will be given a reference answer and the assistant’s answer. Begin your evaluation by comparing the assistant’s answer with the reference answer. Identify and correct any mistakes. The assistant has access to an image alongwith questions but you will not be given images. Therefore, please consider only how the answer is close to the reference answer. The reference answer and the assistant’s answer both describe a mid-level step towards completing a high-level goal, you must consider if these two mid-level steps are similar. If the assistant’s answer is not exactly same as or similar to the answer, then he must be wrong. Be as objective as possible. Discourage uninformative answers. Also, equally treat short and long answers and focus on the correctness of answers. After providing your explanation, you must rate the response with either 0, 0.5 or 1 by strictly following this format: “[[rating]]”, for example: “Rating: [[0.5]]’́.\n\n[Question]\n{question}\n\n[The Start of Reference Answer]\n{ref_answer_1}\n[The End of Reference Answer]\n\n[The Start of Assistant’s Answer]\n{answer}\n[The End of Assistant’s Answer]
- •
Mid-to-low in hierarchy planning: [Instruction]\nPlease act as an impartial judge and evaluate the quality of the response provided by an AI assistant to the user question displayed below. Your evaluation should consider correctness and helpfulness. You will be given a reference answer and the assistant’s answer. Begin your evaluation by comparing the assistant’s answer with the reference answer. Identify and correct any mistakes. The assistant has access to an image alongwith questions but you will not be given images. Therefore, please consider only how the answer is close to the reference answer. The reference answer and the assistant’s answer both describe a trajectory of low-level automic actions towards completing a mid-level step, you must consider if these two trajectories of low-level atomic actions are similar, especially the key actions to achieve the mid-level step. If the assistant’s answer is not exactly same as or similar to the answer, then he must be wrong. Be as objective as possible. After providing your explanation, you must rate the response on a scale of 0 to 10 by strictly following this format: “[[rating]]”, for example: “Rating: [[5]]”.\n\n[Question]\n{question}\n\n[The Start of Reference Answer]\n{ref_answer_1}\n[The End of Reference Answer]\n\n[The Start of Assistant’s Answer]\n{answer}\n[The End of Assistant’s Answer]
- •
Feedback in reward modeling: [Instruction]\nPlease act as an impartial judge and evaluate the quality of the response provided by an AI assistant to the user question displayed below. Your evaluation should consider correctness and helpfulness. You will be given three reference answers and the assistant’s answer. Begin your evaluation by comparing the assistant’s answer with the reference answers. Identify and correct any mistakes. The assistant has access to an image alongwith questions but you will not be given images. Therefore, please consider only how the answer is close to the reference answers. If the assistant’s answer is not exactly same as or similar to all reference answers, then he must be wrong. If the assistant’s answer is exactly same as or similar to any one reference answer, then it is correct. Be as objective as possible. Discourage uninformative answers. Also, equally treat short and long answers and focus on the correctness of answers. After providing your explanation, you must rate the response with either 0, 0.5 or 1 by strictly following this format: “[[rating]]”, for example: “Rating: [[0.5]]”.\n\n[Question]\n{question}\n\n[The Start of Reference Answer]\n{ref_answer_1}\n[The End of Reference Answer]\n\n[The Start of Assistant’s Answer]\n{answer}\n[The End of Assistant’s Answer]

## Appendix B Case Studies

Figure: Figure 6: Case of object interaction in video question answering.
Refer to caption: x6.png

Figure: Figure 7: Case of object count of video question answering.
Refer to caption: x7.png

Figure: Figure 8: Case of action count of video question answering.
Refer to caption: x8.png

Figure: Figure 9: Case of scene transition of video question answering.
Refer to caption: x9.png

Figure: Figure 10: Case of the high-to-mid task in hierarchy planning.
Refer to caption: x10.png

Figure: Figure 11: Case of the mid-to-low task in hierarchy planning.
Refer to caption: x11.png

Figure: Figure 12: Case of the object grounding in visual grounding. The output of GroundingGPT represents percentage.
Refer to caption: x12.png

Figure: Figure 13: Case of frame grounding in visual grounding.
Refer to caption: x13.png

Figure: Figure 14: Case of temporal grounding in visual grounding.
Refer to caption: x14.png

Figure: Figure 15: Case of the critique task in reward modeling.
Refer to caption: x15.png

Figure: Figure 16: Case of the feedback task in reward modeling.
Refer to caption: x16.png

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: Please address my concerns in the Weaknesses part.
soundness: 3
strengths: - MLLMs for embodied AI is a timely topic. The paper built the benchmark on Ego4D, which contains real-world recorded egocentric videos, providing a realistic environment for evaluating embodied AIs. 

- Many benchmark designs reflect the paper's consideration of leveraging video content in embodied AI, e.g., separating VQA questions into object, action, and scene, last-frame-based object grounding, and reward modeling.
summary: The paper proposes a benchmark for evaluating Multimodal Large Language Models' capability to understand egocentric videos motivated by embodied AI. The proposed dataset, VidEgoThink, is built upon Ego4D and benchmarks a range of tasks, including video question answering, hierarchy planning, visual grounding, and reward modeling. The experiments evaluate GPT-4o and image/video-based MLLM methods. The findings suggest that foundation models still require significant advancements to be effectively applied to first-person scenarios in Embodied AI.
weaknesses: - My biggest concern is the data diversity. The authors also admitted that in the paper's limitations section. Many of the benchmark tasks only cover fewer than 50 original videos in Ego4D, while the entire Ego4D dataset contains 9,611 videos. As a concrete example, the Object subtask in VQA covers 29 original Ego4D videos spanning over 9 scenes. This yields to 3 videos per scene. Another example is the Object subtask in Visual Grounding, which yields fewer than 2 videos per scene for 25 scenes. It might not be a significant issue to reach the findings of the paper that all MLLMs suck. However, it is quite problematic for it to be potentially adapted by the research community for wider research. Hence, the usefulness of VidEgoThink in its current scale is limited.  

- The paper sets good motivation for embodied AI, but in the real annotation, they seem to not be implemented. In the Introduction, the paper says that "compared to the absolute position in the whole environment (e.g., the microwave is in the kitchen), the relative position to Ego is more important (e.g., the microwave is one meter to my right) for interaction and manipulation." However, in the Figure 2 Scene Existence example, the question is "Where is the oven located in the video?" and the answer is "The oven is located in the kitchen." I didn't find other annotation examples that could match the Introduction claim. 

- Ego4D videos are pre-recorded. Hence, they might have difficulty (or are even unsuitable to) evaluating task planning compared to an interactive environment. For example, to reach a high-level goal, there might be different orders of mid-level steps or omitting/adding mid-level steps as long as they lead to the final correct results. However, pre-recorded videos contain just one path for implementing the goal. This leads to a quite biased evaluation, especially when the number of videos covering the task is small, as in the proposed VidEgoThink. 

- The paper uses GPT-4o to generate ground truth, e.g., feedback. The paper then evaluates GPT-4o. And, it is possible that the paper uses GPT-4o to implement method evaluation, e.g., g(\cdot) in Eq. 1. (I couldn't find details.) This seems problematic.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 4
questions: A potential reason for rejection could be that readers might perceive the near-zero accuracy of most models on the Hierarchy Planning and Visual Grounding tasks as a sign of flawed benchmark design or errors in the evaluation method. This perception could fundamentally undermine the paper’s contribution. Could you provide more details to explain this phenomenon? whether they align with expectations given the difficulty of the tasks?
soundness: 3
strengths: 1. This paper is well-organized and clearly written.
2. The benchmark tasks are thoughtfully designed and effectively aligned with real-world Embodied AI applications. 
3. The benchmark efficiently leverages the large-scale Ego4D dataset along with its existing annotations, and utilizes GPT to generate new, sensible labels.
summary: This paper presents benchmarks designed to assess the ability of Multi-modal Large Language Models to understand egocentric video, particularly for applications in Embodied AI. There are 4 benchmarks, Video Question Answering, Hierarchy Planning, Visual Grounding, and Reward Modeling, which are well aligned with Embodied AI applications.  The benchmark dataset is constructed using an automated pipeline that leverages the Ego4D dataset and GPT-4o to generate data, and there are 3 human inspectors. Extensive experiments are conducted with 14 MLLMs, including API-based models like GPT-4o, and open-source image-based and video-based models.
weaknesses: 1. Limited Insight from Experimental Results: Although the paper dedicates considerable space to clearly outlining the benchmark tasks in detail, the experimental analysis section is confined to just one page, making the overall work feel incomplete. The key takeaway from the analysis of this paper is that "MLLMs perform poorly across all tasks", but there is a lack of specific insights. For instance, the paper does not provide detailed analysis of performance variations under different test conditions or highlight which model structures perform better on certain tasks. Despite evaluating over 10 different MLLMs, the analysis focuses mainly on GPT-4o, neglecting a deeper exploration of the comparative performance of other models. Furthermore, while the paper emphasizes embodied AI applications, the experimental analysis does not offer actionable insights or future directions for MLLM design from an embodied AI perspective.

2. Limited Novelty in Benchmark Design: The Video Question Answering benchmark overlaps with existing egocentric video QA frameworks, such as EgoTaskQA: Understanding Human Tasks in Egocentric Videos. In Visual Grounding, the tasks like object detection, frame and temporal grounding adhere to traditional task formats, offering little innovation in task design. This reduces the impact of the benchmark’s contribution in terms of novelty.

---

confidence: 3
contribution: 1
initial_rating: 3
presentation: 2
questions: My questions have been included in the Weaknesses section. I primarily suggest that the authors provide additional explanations and analysis.
soundness: 1
strengths: 1. Developing benchmarks to advance MLLMs in Embodied AI remains relatively under-explored and warrants deeper investigation. 

2. The proposed benchmark, VidEgoThink, encompasses diverse tasks to challenge MLLMs across multiple dimensions. 

3. Experimental results highlight the limitations of current MLLMs in egocentric video understanding, pointing to important directions for future research.
summary: This paper introduces a new benchmark to evaluate Multimodal Large Language Models (MLLMs) for egocentric video understanding, advancing their applications in Embodied AI. The benchmark includes four tasks: video QA, hierarchical planning, visual grounding, and reward modeling. Annotations are derived from the Ego4D dataset, processed by GPT-4o, and refined by human annotators to meet task requirements. Experiments with state-of-the-art image and video MLLMs reveal significant gaps in specific competencies.
weaknesses: **1. Limited Contributions**

1.1 The proposed benchmark primarily combines tasks from prior work, such as egocentric video question-answering [1,2] and hierarchical planning [3,4], with data drawn from established annotations—Ego4D narrations for Video QA, goal-step hierarchies for planning, and Visual Queries for grounding. Moreover, similar studies have leveraged LLMs to process Ego4D annotations [2,5,6]. Could the authors clarify how VidEgoThink's approach to processing Ego4D annotations distinguishes itself from or advances existing works? Table 3 lacks persuasive evidence, as previously noted, the ‘task types’ predominantly stem from existing benchmarks.

1.2 Despite noting poor performance in planning and grounding tasks, the authors neither suggest specific enhancements nor discuss pathways for future model improvement. What targeted model enhancements do the authors suggest to address these shortcomings? Additionally, how might advancements on this benchmark translate into practical applications for embodied AI? I encourage the authors to provide a detailed discussion on these points.

**2. Ambiguities in Design and Conclusions**

2.1 The stated motivation is to advance embodied AI (L53), yet the evaluation approach—presenting a complete video and question to the MLLMs—deviates from typical embodied agent operations, which would ideally process video in a streaming fashion [7,8]. Could the authors discuss how their evaluation method aligns with or differs from real-world embodied AI applications?

2.2 The rationale behind defining the dimensions of Video QA is unclear. For example, why is there an object prediction but no action prediction?

2.3 The necessity of visual input for the Mid-to-Low Planning task is unclear. Based on the task description and Figure 3, this task appears potentially solvable using LLM knowledge alone. Performance results in Table 2 show that GPT-4o performs better with 8 frames than with 32 frames, which may support this view. However, the lower performance of the ‘only-qa’ and ‘captions’ baselines suggests inconsistencies. Could the authors clarify why visual input is necessary for the Mid-to-Low Planning task and explain the seemingly contradictory results?

2.4 MSE is listed as the metric for frame grounding (L300), yet it contradicts Equation 3. Is this a typo?

2.5 While the authors mention that GPT-4o does not support video input (L425), they do not explore API models such as Gemini 1.5, which do have video input capabilities. This omission raises questions about the choice of model for evaluation.

---
[1] Majumdar, Arjun, et al. "Openeqa: Embodied question answering in the era of foundation models." In CVPR. 2024.

[2] Di, Shangzhe, and Weidi Xie. "Grounded Question-Answering in Long Egocentric Videos." In CVPR. 2024.

[3] Shridhar, Mohit, et al. "Alfred: A benchmark for interpreting grounded instructions for everyday tasks." In CVPR. 2020.

[4] Song, Yale, et al. "Ego4d goal-step: Toward hierarchical understanding of procedural activities." In NeurIPS. 2024.

[5] Ramakrishnan, Santhosh Kumar, Ziad Al-Halah, and Kristen Grauman. "Naq: Leveraging narrations as queries to supervise episodic memory." In CVPR. 2023.

[6] Mangalam, Karttikeya, Raiymbek Akshulakov, and Jitendra Malik. "Egoschema: A diagnostic benchmark for very long-form video language understanding." In NeurIPS. 2023.

[7] Qian, Rui, et al. "Streaming long video understanding with large language models." arXiv:2405.16009 (2024).

[8] Zhang, Haoji, et al. "Flash-VStream: Memory-Based Real-Time Understanding for Long Video Streams." arXiv:2406.08085 (2024).

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: Refer to weaknesses.
soundness: 2
strengths: The paper has several strong aspects:

1.This paper is the first to integrate four key tasks—video question-answering, hierarchical planning, visual grounding, and reward modeling—covering a broad spectrum from task planning and video understanding to spatial-temporal reasoning and fine-grained task completion awareness. This reflects the authors' deep understanding of the requirements for low-level control tasks in Embodied AI scenarios.

2.For each task, the authors attempt to define clear evaluation dimensions and metrics, providing a usable approach to assessing performance.

3.The experiments show that VidEgoThink is a robust benchmark that effectively highlights the limitations of current MLLMs in processing first-person perspective data.
summary: The paper introduces VidEgoThink, a benchmark for evaluating egocentric video understanding in low-level control tasks within Embodied AI. VidEgoThink employs GPT-4o and prompt engineering to generate question-answer pairs from the Ego4D dataset, focusing on four tasks: video question-answering, hierarchical planning, visual grounding, and reward modeling. Human filtering is applied to ensure the quality of the benchmark. In subsequent evaluations, the benchmark reveals that all current multimodal large language models (MLLMs), including GPT-4o, perform poorly across these tasks.
weaknesses: I see the following as weak points:
1. The quality of VidEgoThink's benchmark data is not thoroughly analyzed.

The paper employs GPT-4o and prompt engineering to generate question-answer pairs from the Ego4D dataset. However, the quality of the benchmark data is not thoroughly analyzed. While it is mentioned that 3 human filters were applied, the filtering criteria are not clearly explained. The statistical analysis in the appendix only covers aspects such as question and answer length, and scene types, which are likely based on the Ego4D dataset's categories. These analyses provide little insight into the overall quality of the benchmark.

I would have liked to see more detailed insights, such as which tasks and actions are included in the benchmark, information on long-term and mid-term tasks along with their difficulty,  as well as which scenes are more challenging, and which are easier. The varying video lengths, differences in activity density, and changing camera perspectives in Ego4D are factors that likely contribute to significant difficulties in video understanding, but these are not addressed.


2. The excessive length of egocentric videos, combined with the inherent difficulty in understanding egocentric scenes, likely leads to the performance decline of all current MLLMs.

Table 3 of the paper shows that the average length of videos in VidEgoThink is 270.74 seconds. However, in the experimental evaluation, only 32 frames, 8 frames, or even captions are used as input. Given that Ego4D has a frame rate of 30 fps and an average video length of around 270 seconds, selecting 32 frames results in sampling roughly one frame every 250 frames. This sparse sampling from such long videos significantly hampers the video perception and understanding capabilities of current MLLMs.

For egocentric videos with complex scenes, numerous background objects, rapid camera movements, and transitions between scenes, such limited input is unlikely to provide sufficient information about the video. This likely also contributes to the generally poor performance of MLLMs.

---

confidence: 5
contribution: 2
initial_rating: 3
presentation: 3
questions: It would be helpful if the authors could clarify the human annotator filtering process and the explanation for weakness points 2,3,4.
soundness: 3
strengths: 1. The benchmark is comprehensive. Four key tasks of video question-answering, hierarchy planning, visual grounding, and reward modeling are designed, and many models including open and closed source LLMs are evaluated.

2. The experimental results reveal that even the most advanced MLLMs struggle with egocentric video understanding, providing valuable insights into areas for potential research and development.
summary: The paper introduces VidEgoThink, a benchmark for evaluating egocentric video understanding capabilities of Multi-modal Large Language Models (MLLMs). It has four key tasks: video question-answering, hierarchy planning, visual grounding, and reward modeling. The authors develop an automatic data generation pipeline to generate the data using GPT-4o from Ego4D dataset. Human annotators are employed to filter the generated data. Experiments are conducted with various MLLMs, including API-based, open-source image-based, and video-based models, showing that current models are still lacking in egocentric video understanding.
weaknesses: 1. The data generation pipeline heavily relies on GPT-4o. The authors claim to use manual inspection on the automatically generated data, however, no detail on the human filtering is provided. For example, how the inspection is done, what instructions are given to the annotators, how many percentages of data are filtered, where the annotators are hired, and at what salary.

2. The benchmark is mainly generated using GPT-4o, and the evaluation is in an open-ended manner. The evaluator is also GPT-4o. This raises the concern that the evaluation is not fair to other models. The evaluation may be not entirely based on the correctness, but partially based on the (language style) similarity to GPT-4o.

3. For the mid-to-low planning task, the authors converted the output style into a "function-like" format. Since the function here is purely verb and noun pairs, I think this is totally unnecessary. It can be also seen from the example figure of this task, where not all models can follow the instructions to generate the answers of the same format, which potentially influences the evaluation result. From the result, all models except GPT-4o get almost completely wrong outputs. I understand the author's claim that this is closer to the "actions" of embodied AI, however in this work it is a simple text re-writing, and I think it is more harmful to the evaluation compared with being "closer to embodied AI".

4. For the object grounding task, the prompt given to the LLMs does not seem to contain enough information. The evaluation is on the last frame of the video, but the prompt just says "Please give out the bounding box coordinates of the object." (L1231)

5. The title of this paper is "for embodied AI". However, only real-world human data is used. While it is understandable that the design of tasks is inspired by embodied AI, I believe this claim is not appropriate. This benchmark is more on the egocentric video understanding side.