\section{Participating Systems}
\label{sec:systems}
\subsection{Baseline}
\label{sec:baseline}
As in the previous edition, we provide two baseline systems: one that predicts empty nodes as placeholders for zero anaphora and another for coreference resolution.
These baseline systems may be used or extended only by participants in the Unconstrained track.

\paragraph{Empty nodes prediction baseline}

As in the previous two years, empty node prediction is a part of the shared task. To
assist participants focusing solely on coreference resolution, we provide
a baseline system for empty node prediction.

This year, the empty node prediction baseline has been updated considerably.
In previous years, the baseline produced only information necessary for the
coreference resolution evaluation---for every empty node, its word order,
dependency parent, and dependency relation were predicted. This year, we extended
the system to predict all available empty node information, additionally providing
the form, lemma, UPOS, XPOS, and FEATS columns.

The baseline model architecture builds on the implementation from previous
years. Each input sentence is processed by
XLM-RoBERTa-large~\citep{conneau-etal-2020-unsupervised} to generate embeddings
for every word. Based on these embeddings, two candidate empty nodes are
predicted per word and processed through eight heads: (1)~a~binary
classification head to determine whether the empty node candidate will produce
an empty node, (2-7)~classification heads predicting the dependency relation,
form, lemma, UPOS, XPOS, and FEATS, and (8)~a self-attention-based word-order
prediction head to identify the insertion point for the empty node. A single
model is trained on a concatenation of all corpora containing empty nodes, with
sentences sampled proportionally to the square root of their respective corpus
sizes.

The source code of the system is available under an open-source license.\footnote{\url{https://github.com/ufal/crac2026_empty_nodes_baseline}}
The trained model is available on Hugging Face\footnote{\small\url{https://huggingface.co/ufal/crac2026_empty_nodes_baseline}} and via LINDAT/CLARIAH-CZ,\footnote{\small\url{https://hdl.handle.net/11234/1-6081}} and is automatically downloaded by the system.

Further information, including a detailed architecture description, training
hyperparameters, and an intrinsic evaluation of predicting all CoNLL-U columns for
all the datasets, is available in~\citet{straka-2026-corpipe}.

\paragraph{Coreference resolution baseline}
The coreference resolution baseline has remained unchanged over the past four years.%
\footnote{\url{https://github.com/ondfa/coref-multiling}}
It is built upon the multilingual end-to-end neural coreference resolution system by \citet{prazak-etal-2021-multilingual}, which extends the original end-to-end model introduced by \citet{lee-etal-2017-end}. The model examines all possible spans up to a predefined maximum length and directly predicts an antecedent for each span. As it does not include a separate mention detection stage, it is particularly suitable for datasets that do not annotate singleton mentions. The baseline uses the mBERT base model as its encoder \citep{DBLP:journals/corr/abs-1810-04805}.
In the remainder of this paper, we use \baseline{} to denote the combination of the two baseline systems, and \baselinegz{}, for coreference resolution baseline applied to gold empty nodes.

\subsection{System Submissions}
\label{sec:system-submissions}

This year, \nsystems{} systems were submitted to the shared task by \nteams{} teams:
UWB,\footnote{UWB = University of West Bohemia.}
LatticeNLP,\footnote{LatticeNLP refers to the system by Antoine Bourgois.}
Landcore,\footnote{Landcore refers to the system by Jan Pavelka.}
PortNLP,
AU-KBC,\footnote{AU-KBC = Anna University - K. B. Chandrasekhar Research Centre refers to the team of Sobha LalithaDevi, Pattabhi R K Rao and Vijay Sundar Ram.}
ÚFAL CorPipe,\footnote{ÚFAL CorPipe submitted three variants: CorPipeLarge, CorPipeXXL, and CorPipeEnsemble.}
Stanford NLP Group,\footnote{Stanford NLP Group is the creator of the Stanza package.}
and LEMN Lab.\footnote{LEMN Lab is the creator of DAggerCoref.}
For clarity, we distinguish the submissions to the LLM track with the `LLM-' prefix in the following text.

\paragraph{LLM-UWB (hejmanj)}
The UWB team fine-tunes large open-source models---primarily \texttt{google/gemma-3-27b-it}, alongside \texttt{gemma-3-12b-it} and \texttt{meta-llama/Llama-3.1-8B}---using QLoRA. Their approach modifies the plaintext format to tag solely the headword of a mention rather than its entire span. They deploy two distinct strategies: an end-to-end processing pipeline applied to most datasets, and a scrolling context window with overlap, which is specifically used on four datasets (namely Dutch-OpenBoek, French-Democrat, French-LitBankFr, Latin-CorefLat) to reduce inference costs. Training involves joint pretraining across all datasets followed by dataset-specific steps. Empty nodes are predicted directly within the generated text. In terms of generation capacity, the models process inputs up to 55,000 tokens and support immense output capacities of 131,072 tokens.

\paragraph{LLM-LatticeNLP (Antoine Bourgois)}
Based on the \texttt{gemma-3-27b-it} model, this system utilizes 4-bit quantization and LoRA adaptation (rank 64). The training relies on a two-stage supervised fine-tuning (SFT) strategy. First, a general adapter is trained across all datasets for one epoch to learn coreference phenomena and format. This is sequentially followed by one to four epochs of continual fine-tuning using a dataset-specific adapter to mitigate inter-dataset guideline discrepancies. The system uses a custom plaintext format relying exclusively on HTML/XML-like tags (e.g., \texttt{<ent8>} and \texttt{<zero2>}) inserted directly after the syntactic heads. During inference, documents are processed in batch queries of six sentences, augmented with an on-the-fly cleaning script to ensure valid contexts are passed to the subsequent generation windows.

\paragraph{LLM-Landcore (pavlk-mm)}
This system treats the shared task entirely as an applied in-context learning problem utilizing Anthropic's closed-source \texttt{Claude Haiku 4.5} model. No parameter updates or fine-tuning techniques are applied. The system transforms the input to an XML-like tagging scheme (e.g., \texttt{<e1>I</e1> sleep}). The constructed prompts are intricately detailed, describing linguistic observations and annotation suggestions alongside three corpus-specific few-shot examples comprising continuous chunks of up to 500 words (with the exception of \texttt{nl\_openbook}, which uses one example due to length). During inference, generations are requested at a temperature of 0. The system does not model or predict empty nodes.

\paragraph{LLM-PortNLP (portnlp)}
This system fine-tunes \texttt{Qwen-3-14B} using QLoRA with 4-bit NF4 quantization. Rather than processing full long documents at once, texts are split at sentence boundaries into 500--700 character chunks. The model resolves each chunk independently, relying computationally on a bounded context from prior generations alongside a novel ``scored entity registry.'' This registry handles up to 30 active entities mathematically managed via a frequency-recency decay formula. Training data included three language-specific few-shot examples, zero anaphora hints, and entity ID permutation augmentation to prevent the model from memorizing fixed entity IDs. To mitigate the dominance of resource-heavy languages (e.g., Czech) during training, temperature-scaled dataset sampling was implemented.

\paragraph{AUKBC-MULCRF (lalithadevi)}
As a participant in the Unconstrained track, this non-neural submission utilizes Conditional Random Fields (CRFs) to construct a multilingual coreference model from scratch. The system functions through a two-step pipeline. First, mentions are identified using UPOS tags, encompassing nouns, proper nouns, and pronouns. Subsequently, coreference chains are consolidated via noun-noun coreference and anaphora resolution methods that rely heavily on heuristic features (like edit distance) and syntactical cues (root words, dependencies, and PNG features). The approach completely omits the modeling of empty nodes.

\paragraph{CorPipeLarge (corpipe-sing-lg)}
This system represents an upgraded variant of their base CorPipe architecture from 2025, now pivoting to the \texttt{google/mt5-large} model comprising 580M parameters. Leveraging a word-level tagging scheme that supports overlapping clusters, the system dynamically predicts mentions and natively resolves coreference links directly via antecedent probabilities. Empty nodes are handled via integration with the shared task's provided baseline system. The system employs a purely multilingual approach, utilizing a batch consisting of 8 sentences, learning over 15 epochs without dataset-specific indicators.

\paragraph{CorPipeXXL (corpipe-single)}
Following the same architectural principles as CorPipeLarge, CorPipeXXL vastly scales the backbone model to \texttt{google/umt5-xxl}, harboring over 6B trainable parameters. To circumvent computational limitations and fit within standard memory constraints, smaller batches (6 sentences) and a reduced learning rate are employed. Additionally, rather than utilizing the exact published empty node baseline, the authors trained a slightly improved standalone baseline model using the provided implementation to inform their inputs.

\paragraph{CorPipeEnsemble (corpipe-ensemb)}
This submission represents a heavyweight amalgamation consisting of an ensemble of seven identically structured CorPipeXXL (\texttt{umT5-xxl}) models. Consequently, the holistic multi-model pipeline contains roughly 42 billion parameters. At inference time, performed expansively across seven parallel GPUs, the predictions are synthesized by averaging the word-level mention-encoding tag probabilities before subsequently averaging the decoded coreference link likelihoods across all constituent models.

\paragraph{Stanza (stanza-coref)}
Operating internally on the Stanza framework, the architecture functions as a head-joining efficient word-level coreference approach. Initially, the core model identifies mentions linked by
textual head words, whereupon semantic spans are resolved locally through an integrated Convolutional Neural Network (CNN). Representations are initialized using frozen \texttt{XLM-RoBERTa-large} embeddings conjoined with a LoRA adapter (34M trainable parameters), continuously sliding over the textual documents utilizing 512-token-wide windows. Empty nodes are acquired externally via the official task baseline.

\paragraph{DAggerCoref (thmorton)}
Submitted by the LEMN Lab to the Unconstrained track, DAggerCoref is a three-stage cascade built on \texttt{XLM-RoBERTa-large}. Stage 1 is a binary gap classifier that inserts learned \texttt{[ZERO]} markers at syntactically plausible empty-pronoun positions using an Otsu-adaptive threshold. Stage 2 is a token-level mention head classifier trained with focal loss. Stage 3 is a coarse-to-fine antecedent scorer using head-only mention representations. A central contribution is training Stage 3 with DAgger: after fitting on gold mentions, the system fine-tunes on a 50/50 mix of gold and predicted mention sequences to expose the scorer to test-time errors. The system is trained multilingually across all datasets without per-language tuning, predicting empty nodes entirely from scratch rather than relying on the provided baseline.

\begin{table*}[!t]
\centering
\begin{tabular}{l l l}
\hline
\textbf{Name} & \textbf{Track} & \textbf{Techniques} \\
\hline
LLM-UWB            & LLM       & FT, QLoRA, joint/scrolling window \\
LLM-LatticeNLP     & LLM       & FT, prompt tuning, QLoRA, quant., continual FT \\
LLM-Landcore       & LLM       & ICL, few-shot prompting \\
LLM-PortNLP        & LLM       & FT, QLoRA, quant., entity registry tracking \\
\hline
AUKBC-MULCRF       & Unconstr. & CRF, heuristic features pipeline \\
CorPipeLarge       & Unconstr. & FT joint mention/link \\
CorPipeXXL         & Unconstr. & FT joint mention/link \\
CorPipeEnsemble    & Unconstr. & FT + ensemble \\
Stanza             & Unconstr. & FT + LoRA, head-joining CNN \\
DAggerCoref        & Unconstr. & 3-stage cascade, DAgger FT, gap classifier \\
\hline
\end{tabular}
\caption{System names, task tracks, and main techniques.}
\label{tab:sys-tech}
\end{table*}

\begin{table*}[!t]
\centering
\begin{tabular}{l l r r r}
\hline
\textbf{Name} & \textbf{Model} & \textbf{Input ctx. len.} & \textbf{Output tok. len.} & \textbf{\#Params} \\
\hline
LLM-UWB            & \small\makecell[l]{Gemma-3-27B/-12B,\\ Llama-3.1-8B}  & 55,000      & 131,072    & 488 M (LoRA) \\
LLM-LatticeNLP     & gemma-3-27b-it               & 3,072       & 536        & 488 M (LoRA) \\
LLM-Landcore       & Claude Haiku 4.5             & 200,000     & 64,000     & —            \\
LLM-PortNLP        & Qwen-3-14B                   & 4,096       & 1,024      & 128.5 M (LoRA) \\
\hline
AUKBC-MULCRF       & CRF pipeline                   & —           & —          & —            \\
CorPipeLarge       & mt5-large                      & 512/2,560   & —          & 580 M        \\
CorPipeXXL         & umt5-xxl                       & 512/2,560   & —          & 6 B          \\
CorPipeEnsemble    & umt5-xxl ($\times 7$)          & 512/2,560   & —          & 42 B         \\
Stanza             & XLM-RoBERTa-large              & 512         & —          & \small\makecell[l]{34M + \\ 548M frozen}  \\
DAggerCoref        & XLM-RoBERTa-large              & 256/512     & —          & $\sim$582 M  \\
\hline
\end{tabular}
\caption{Models: model name, maximum input context length, maximum new tokens generated, and model sizes. Trainable LoRA parameter sizes are noted explicitly where applicable.}
\label{tab:context-size}
\end{table*}

\begin{table*}[!t]
\centering
\begin{tabular}{l l r r l}
\hline
\textbf{Name} & \textbf{Empty nodes} & \textbf{Batch size}    & \textbf{Grad ups} & \textbf{Tuned h-params} \\
\hline
LLM-UWB             & predicted    & 1--2           & $\sim$171 k      & model choice, window size   \\
LLM-LatticeNLP      & predicted    & 32             & $\sim$6 k        & plaintext type, epochs      \\
LLM-Landcore        & predicted    & few-shot       & 0                & —                           \\
LLM-PortNLP         & predicted    & 16             & $\sim$10.5 k     & none                        \\
\hline
AUKBC-MULCRF    & baseline           & NA             & NA               & —                           \\
CorPipeLarge    & baseline           & 8 sentences    & 150 k            & learning rate               \\
CorPipeXXL      & improved baseline  & 6 sentences    & 150 k            & learning rate               \\
CorPipeEnsemble & improved baseline  & 6 sentences    & 150 k $\times$ 7 & learning rate               \\
Stanza          & baseline           & 10 $\cdot$ 512-tokens & 255 k            & \small\makecell[l]{learning rate, warmup,\\LoRA params, \dots} \\
DAggerCoref     & predicted (scratch)& 4--32          & $\sim$115 k      & \small\makecell[l]{loss type, thresholds,\\DAgger mix, LRs, \dots} \\
\hline
\end{tabular}
\caption{Training configuration: empty-node handling, batch sizes, total gradient updates, and tuned hyperparameters. Stanza uses a batch size comprised of 10 windows (each 512-tokens long).}
\label{tab:train-config}
\end{table*}

\subsection{System Comparison}\label{sec:system-comparison}
\paragraph{Overview of tables}
Tables~\ref{tab:sys-tech}--\ref{tab:train-config} provide a comprehensive comparison of all submissions. Table~\ref{tab:sys-tech} enumerates each system’s shared-task track, primary pretrained architecture, and core methodological mechanisms (e.g., parameter efficient fine-tuning, in-context learning, entity registries, head-joining). Table~\ref{tab:context-size} details respective computational characteristics, mapping out each inference configuration’s input size, maximum generation cap, and total trainable parameter count. Finally, Table~\ref{tab:train-config} outlines specialized training configurations, documenting empty node conventions, batching heuristics, and total gradient updates.
While all teams leverage the official CoNLL-U dataset infrastructure, explicit divisions emerge concerning foundational text manipulation, context capacities, LLM application paradigms, and dataset-specific domain adaptations.

\paragraph{Modeling paradigms}
The task yielded four diverse contributions to the LLM track and six dedicated to the Unconstrained track. All LLM approaches opted to map the coreference resolution directly into a generative task. No agent or iterative approaches were involved. Submissions like LLM-UWB, LLM-LatticeNLP, and LLM-PortNLP employ supervised fine-tuning of selected large language models (Gemma-3, Qwen-3, Llama-3.1) utilizing quantized variants of the LoRA framework. The models were trained to generate either customized XML-like markup or target plaintext datasets. LLM-Landcore demonstrated an entirely training-free variation of generation leveraging well-engineered few-shot in-context prompts directed to Anthropic's proprietary Claude models.
Meanwhile, architectures in the Unconstrained track typically maintain traditional machine learning pipelines bridging mention detection functionality with sequential pair scoring algorithms. Teams predominantly utilize sequence-to-sequence encoder-decoder grids tailored explicitly to classification properties (CorPipe natively deploying \texttt{mT5}/\texttt{umT5}) or rely strictly on embedded representation analysis via CNNs tracking dense span overlaps (Stanza). Similarly leveraging \texttt{XLM-RoBERTa-large}, DAggerCoref introduces a three-stage cascade (gap classification, mention head classification, and antecedent scoring), uniquely employing DAgger fine-tuning to train on a mix of gold and predicted mentions. Amidst these neural approaches, one distinct outlier is AUKBC-MULCRF, electing to deploy highly specialized non-neural Conditional Random Fields (CRFs).

\paragraph{Context capacity and model scale}
Exploiting inherent advancements within foundational models, the contextual ceiling across systems drastically scaled compared to preceding iterations of the task. LLM-Landcore comfortably navigates prompts reaching limits of 200,000 subwords, whilst LLM-UWB optimized models to parse document scales generating effectively 131,072 target tokens. To offset computational overhead on larger language paradigms, system heuristics actively engineered clever solutions, such as LLM-PortNLP utilizing segmented bounding thresholds (500--700 characters) conjoined iteratively with a decay-driven scored entity registry. Machine learning approaches inside the Unconstrained boundaries still largely hinge on sequentially confined subword limits (512 blocks traversing to 2,560 inferences within the generalized CorPipe structures, or 256 to 512 subword windows in the case of DAggerCoref). Overall model parametrization varied drastically globally; the heaviest iteration utilized 42B cumulative variables (CorPipeEnsemble), dropping as far below as 34M trainable elements inside localized Stanza adapters, with mid-sized models like DAggerCoref sitting around 582M parameters.

\paragraph{Data usage and sampling considerations}
Universally adhering to competition constraints, external data was circumvented. However, internal sampling routines encountered notable shifts. Systems actively acknowledged the dataset disparities; for example, LLM-PortNLP intentionally executed temperature-scaled language sampling arrays, mathematically restricting the systemic Czech language distribution from heavily dominating cross-linguistic training batches. Likewise, randomization heuristics such as dataset ID permutation augmentation were utilized to ensure neural focus remained heavily fastened to linguistic features rather than entity ID integer memorization. Another novel approach to training data manipulation was introduced by DAggerCoref, which employs DAgger fine-tuning by explicitly mixing 50\% gold and 50\% predicted mention sequences during training to expose the model to realistic inference-time errors.

\paragraph{Empty node handling}
In approaches towards implicit zero-anaphora variables, system configurations split generally along paradigm constraints. For strictly generative networks resolving empty nodes natively (LLM-UWB, LLM-LatticeNLP, LLM-PortNLP, LLM-Landcore), resolutions happen end-to-end within internal text generations relying on distinct formatting rules (e.g. \texttt{<zero2>} injection mapping inline XML boundaries). %Conversely, LLM-Landcore deliberately skipped modeling them.
%\todo{Opravil jsem zde, že Landcore generuje empty nodes.}
Within the Unconstrained boundaries, baseline incorporation fundamentally ruled the architectures; AUKBC-MULCRF, CorPipeLarge, and Stanza strictly utilized predictions derived directly via the standard task baseline parameters, while CorPipeXXL and CorPipeEnsemble utilized a refined localized train-out of the same baseline framework. In contrast, DAggerCoref stands out in the Unconstrained track by discarding the baseline entirely, instead predicting empty nodes from scratch via a dedicated gap classifier that inserts learned \texttt{[ZERO]} sentinel tokens based on dependency information.
%Finally, AUKBC-MULCRF opted to entirely skip modeling empty nodes altogether.
% Martin: to není pravda, AUKBC-MULCRF vyplnili v dotazníku, že použili baseline predikce.

\paragraph{Language/treebank specialization and ensembling}
The architectural dichotomy balancing monolithic global models and dataset-specified routing persists. Most submitted platforms (CorPipe structures, Stanza, AUKBC-MULCRF, LLM-PortNLP) prefer consolidating weights cross-lingually to formulate powerful general-domain models seamlessly reacting to implicit syntax. For instance, DAggerCoref trains a single joint model across all 27 datasets; however, the authors noted this monolithic approach struggled with ancient languages (e.g., Ancient Hebrew, Old Church Slavonic) due to the limited exposure of the underlying XLM-R encoder to classical corpora. Breaking from this purely global strategy, LLM-LatticeNLP represents a noticeable hybrid progression, establishing sequential staging wherein a broad format-aware foundational epoch dictates general coreference metrics, structurally succeeded by dedicated individual language/dataset-specific adapters continuously trained over separate discrete epochs. LLM-UWB similarly compartmentalizes domain behaviors based heavily around whether document bounds enforce the requirement for a separate computational scrolling-context subset fine-tune. Only CorPipeEnsemble relied strictly on parallel inference scaling dynamics, processing outcomes simultaneously across seven identically structured \texttt{umT5-XXL} instances.

%\formk{distill and integrate comparison of modeling on mention heads or full spans}