Reuse by Design: A Pivot-Based Architecture for the KIParla Corpus of Spoken Italian

1.1 The KIParla corpus

The KIParla corpus was conceived to provide a large-scale, carefully constructed collection of spontaneous spoken Italian. Initiated in 2016 and developed through the years as a collaboration between the Universities of Bologna and Turin, KIParla was designed from the outset as a modular and extensible corpus, with new modules added over time following shared transcription conventions and compatible metadata structures. The corpus currently comprises six released modules - KIP (Goria & Mauri, 2018), KIPasti (Mauri et al., 2024a), ParlaBO (Mauri et al., 2024b), ParlaTO (Cerruti & Ballarè, 2021), StraParlaBO and StraParlaTO (Mauri et al., 2025) - and several under development in collaboration with other Universities (University of Bozen, Naples, Munich), covering a wide range of interactional settings such as free conversations, semi-structured interviews, lectures, oral exams, and office hours, recorded in different Italian regions and social contexts. Rich speaker and conversation metadata support sociolinguistic and interactional analyses across age, occupation, educational background, and communicative situation. As of today, the resource counts ca. 350 hours of recorded and transcribed conversation for a total of approximately 3,200,000 tokens.

The architecture of KIParla is grounded in a principled combination of modularity and incrementality. Each module is designed as internally balanced, constructed according to explicit sampling criteria and sociolinguistic parameters, and can be queried independently as a self-contained dataset. The modules are however structurally interoperable, sharing annotation standards, metadata schemes, and design principles that allow them to be searched jointly. When considered separately, each module supports fine-grained analyses within a controlled domain; when interrogated together, the corpus provides a broader empirical space in which patterns can be compared across contexts, speaker profiles, and interactional settings.

This dual architecture is what makes KIParla capable of sustained growth without sacrificing methodological rigor. Crucially, expansion does not dilute balance or comparability, because every new module enters the system as a structured and calibrated unit.

1.2 The input data: limitations and potentialities

The KIParla pipeline (Figure 1) has been followed for each published module. It starts with data collection: a shared process brought about by a community of workers, including the PI responsible for the module, various researchers up to students and interns who actively take part in the fieldwork. Such a collective effort continues in the upcoming phases: namely, archiving and transcribing. The corpus is orthographically transcribed and enriched with a set of transcription conventions inspired by Jefferson (2004), a widely adopted system in Conversation Analysis due to its expressive power and ability to capture fine-grained interactional detail. Through ELAN (Max Planck Institute For Psycholinguistics, The Language Archive, 2025; Wittenburg et al., 2006), the audio recordings are transcribed into speaker-dependent units, aligned with the audio (.wav) input.

Figure 1

A single expert linguist is then in charge of the overall revision and pseudonymization, to guarantee an acceptable level of internal consistency in the workflow, despite the many different people that intervened during the process, and the difficulties in undertaking extensive and systematic inter-annotator agreement monitoring (see Artstein and Poesio (2008); Gagliardi (2018) for a critical discussion).

The outcome of the data processing phases is an eaf file: a textual XML object to be interpreted only by means of the ELAN software (Figure 2). From this, in order to make the data readable and partially queriable through concordancers such as noSketchEngine (Institute of the Czech National Corpus, 2025), a number of linearized representations have to be derived. For instance Figure 3 shows that the orthographic representation derived from the corresponding Jeffersonian one deletes overlaps (e.g., ‘[no no no]’ > ‘no no no’), prolongations (e.g., ‘venuta::’ > ‘venuta’), intonation patterns (e.g., ‘colloquio,’ > ‘colloquio’).

Figure 2

Figure 3

The full eaf transcriptions come with some limitations: (i) they are not natively compatible with widely used computational formats and standards, (ii) the format does not come with clear unit descriptions, (iii) the process that brings data to this output is very difficult to scale, and (iv) it is very difficult to revert decisions that have been taken along the way. The lack of a clear multilayer annotation format makes it hard to reuse, automate or investigate aspects independently from one another.

KIParla faces a more general problem in spoken language research: annotation pipelines are often opaque, time-consuming, and difficult to validate, and the resulting data products tend to crystallize ad-hoc analytical choices that are hard to revise, extend, or align with other resources. At the same time, as interests in modeling language in interaction grows both in the humanities and in natural language processing, the need for fully machine readable representations grows as well. Yet, such representations must be able to fully preserve the richness of the original annotation and avoid reducing the data to out of context sentence-level representations.

1.3 Motivation: a pivot format for reuse-oriented workflows

Spoken language research is characterized not by a lack of standards, but by the coexistence of partially incompatible ones, each optimised for specific stages of the data lifecycle. Formats such as .chat (MacWhinney, 2019) and .eaf (Wittenburg et al., 2006) have proven highly effective for transcription and interactional analysis. However, neither is designed to function as a stable operational format for large-scale linguistic annotation, querying, and infrastructural integration. In both cases, additional annotation layers tend to be external or tool-dependent, limiting extensibility and interoperability across workflows.

The TEI-based ISO standard “Transcription of spoken language” (ISO 24624:2016) (Hedeland & Schmidt, 2022; Werthmann, 2025) addresses structural heterogeneity by providing a shared exchange model grounded in the TEI Guidelines. Its macro-structure supports participants, timelines, and speaker contributions, while allowing theory-dependent variation at the micro-level. ISO 24624 is highly effective as a documentation and conversion standard, facilitating preservation and interoperability across projects. However, it is rarely used as an operational working format for continuous dataset development. In practice, it functions as a target of conversion rather than as the maintained source representation through which annotation, validation, and querying are routinely performed.

Reuse-oriented workflows such as those envisioned for KIParla require a different kind of representation: one that is lightweight, line-oriented, and directly compatible with token-based query systems. In particular, a pivot format should (i) support version control and diff-based inspection, (ii) allow straightforward integration of additional annotation layers, and (iii) serve as a single maintained source from which alternative representations can be reproducibly derived.

A further architectural limitation concerns the hierarchical nature of XML-based formats. XML enforces a strictly nested structure, whereas spoken interaction frequently involves non-hierarchical phenomena such as overlapping speech. While such phenomena can be represented indirectly through references or stand-off annotation, they do not exist as first-class structural objects within the tree model. For reuse scenarios requiring explicit, manipulable representations of relational phenomena, this constraint becomes significant.

The pivot format introduced for KIParla addresses these issues by adopting a vertical, pseudo-tokenized, tab-separated structure in which each row corresponds to a validated transcription-derived token. This format functions as an operational core: it mediates between interaction-oriented transcription practices and computational infrastructures, enabling continuous validation, version-controlled maintenance, and reproducible derivation of alternative representations. Crucially, it has been designed to allow researchers to inspect and understand the data directly, using nothing more than a text editor or spreadsheet software, while remaining fully compatible with automated processing. Basic transformations, validation steps, and exploratory analyses can be performed using standard command-line tools (e.g., grep, awk, sed) or widely available applications such as spreadsheet editors, without the need for specialized tooling. This emphasis on co-readability reflects a reuse-oriented design philosophy: human readability supports quality control and fast prototyping, while machine readability enables automation, reproducibility, and integration with infrastructure services.

It is important to stress that the pivot format is not intended to replace XML-based standards such as TEI/ISO 24624, which remain essential for archiving, long-term preservation, and cross-project interoperability. Rather, it is conceived as an operational complement suited to the active development phase of the corpus, when data are frequently revised, validated, and extended. During this phase, the line-oriented, tab-separated structure offers a decisive practical advantage over XML: whereas XML requires specialized parsers, schema-aware editors, and considerable technical expertise to inspect or modify safely, the pivot representation can be opened, read, queried, and corrected directly in any text editor or spreadsheet application. A researcher can perform quality-control checks or isolate specific annotation layers using a single command-line instruction (e.g., grep, awk) without relying on XML toolchains. These properties make the pivot format specifically suitable as a maintained working representation during corpus development, while XML-based formats retain their role as targets for archival conversion and interoperability exchange.

3.1 Transcription units: structural normalization and coherence

The conversion process begins by treating the transcript as an ordered sequence of speaker-attributed TUs, operationally defined adspeaker-labeled segments associated with a time interval and a Jefferson-formatted annotation string. The workflow accepts segmentation as given, but subjects it to structural validation.

Each TU is standardized to remove extraneous symbols, regularize spacing and normalize formatting irregularities: this ensures that surface variability does not propagate into downstream structural analysis.

Validation also verifies that each TU is structurally well-formed: it must be anchored to a coherent time interval (end > start), and must contain interpretable annotation content. Units that collapse to empty or purely non-linguistic material after normalization can be excluded from further processing. The result of this stage is a temporally ordered sequence of normalized TUs that are internally consistent and suitable for more fine-grained structural analysis.

Each unit is finally assigned an ID unique within the speech event.

3.2 Spans: delimiter balance and alignment with temporal overlap

The second stage concerns span-like phenomena, that is, Jefferson devices that extend over a contiguous stretch of text. These include low-volume segments, altered pace segments, guessing/uncertain hearing markers, and bracketed overlap regions.

Span-level validation proceeds in two steps. First, delimiter balance is verified within each TU. All paired markers must be properly opened and closed; unbalanced or malformed delimiters are treated as structural errors. This ensures that the annotation string can be interpreted as a coherent sequence of span delimiters that are locally balanced, without imposing a strict nesting constraint across different Jefferson devices: in keeping with Jeffersonian practice, overlapping or interleaving patterns across distinct marker types (e.g., la seconda lingua strani[era <in]glese:> cioè >la la prima lingua [stran]iera inglese< oppure, ‘my second foreign language english well my my first foreign language english or’) are treated as formally admissible, provided that each delimiter type is internally well-formed.

This interpretation also requires disambiguating symbols that can function both as opening and closing delimiters, such as the angle bracket. In Jefferson notation, the same graphic symbol (e.g., >) may mark either the beginning or the end of a paced segment, depending on context. To render such cases computationally tractable, we adopt explicit structural assumptions: for instance, stretches marked by >…< and <…> are treated as internally coherent units that cannot be interwoven or ambiguously concatenated.

Spans must be anchored to a clearly defined address space: in this framework, spans are linked to token indices. Validation ensures that span boundaries refer to existing tokens (i.e., cover at least one linguistic character) and are non-empty. To this end, certain surface configurations are normalized prior to span projection. For example, an opening parenthesis cannot be followed by a space (e.g., [ word ↦ [word), and a closing parenthesis cannot be preceded by a space, so that the delimited material is directly attached to the relevant token rather than floating between tokens. Similarly, in the case of vowel prolongations, spans must include at least one alphabetic character of the affected token. Configurations in which the span would otherwise consist solely of prolongation markers are therefore adjusted: sequences such as word[:: ↦ wor[d::, and sequences such as word]. ↦ word.], ensuring that the span includes at least one segment of lexical material and can be reliably mapped onto a token-level character range. Overlaps require special attention as they are validated against the temporal structure of the transcript.

They represent the most complex phenomenon in the conversion pipeline, because their identification relies on two partially independent sources of information: (i) temporal alignment, and (ii) textual span annotation using Jefferson brackets. The working assumption of the pipeline is that these two sources should converge: overlap events detectable from time intervals should correspond to bracketed overlap spans in the transcription string. The algorithm therefore derives overlap events from temporal data and subsequently matches them to annotated spans.

The first step consists in constructing a temporal overlap graph over TUs. Each unit is represented as a node; an undirected edge is introduced between two nodes if their time intervals intersect (i.e., if both units are simultaneously active for a non-zero duration). Since a unit may overlap with multiple other units the resulting structure is generally not a simple pairwise mapping but a graph encoding all temporal intersections. Figures 4 and 5 illustrate two prototypical configurations that motivate the graph-based treatment of overlap. In the first case, a single TU participates in more than one temporally distinct overlap event: one unit overlaps with a second unit during an initial time window and later overlaps with a third unit during a different time window. This situation involves three units overall, it corresponds to two separate overlap events, because there is no time interval during which all three units are simultaneously active. In the overlap graph, this configuration yields two distinct cliques sharing a common node. In the second case, three speakers are simultaneously active within a shared temporal interval. Here, the overlap graph contains a fully connected subgraph among the three corresponding units, forming a maximal clique. This clique defines one overlap event whose temporal boundaries are given by the maximum of the units’ start times and the minimum of their end times.

Figure 4

Figure 5

Overlap is therefore not defined pairwise but event-wise, as maximal cliques (a set of two or more units that are mutually overlapping during a shared temporal window and that cannot be extended to more units) on the graph. For each clique, the algorithm computes its temporal boundaries that defines the effective time span during which all units in the clique are simultaneously active. Each such interval is treated as a distinct overlap event and assigned a unique identifier within the speech event. Overlap events can then be ordered chronologically based on their onset time.

The validator also performs minor refinements shifting unit boundaries when time-derived overlaps seem spurious.

For each TU, the algorithm determines which overlap events include that unit. Ideally, if a unit participates in n temporal overlap events, the Jefferson transcription of that unit should contain n bracketed overlap spans. To establish correspondence, both temporal events and textual spans are ordered, based on their onset time or their position in the annotation string. The matching then proceeds sequentially.

The matching procedure is subject to additional constraints such as excluding nonverbal tokens from overlap participation and ignoring spans that violate structural constraints.

Each token that falls within a textual overlap span inherits the identifier of the corresponding temporal overlap event. In this way, overlap becomes a relational structure linking tokens across units. Concretely, if tokens t₁ (unit A), t₂ (unit B), and t₃ (unit D) in Figure 5 all belong to the same overlap event identifier, the vertical format makes explicit that these tokens were produced within the same temporal overlap window. This makes explicit information that is only implicit in Jefferson transcription. Human annotators mark the presence of overlap locally, but they do not specify which bracket in one unit corresponds to which bracket in another.

3.3 Tokens: local well-formedness and feature extraction

The final stage operates at the level of tokens. Because Jefferson conventions do not define token boundaries, the workflow adopts an explicit tokenization scheme. Tokenization proceeds within each TU by splitting the normalized annotation on whitespace while also treating the prosodic-latching marker (=) as a separable element; the splitter preserves = as its own item so that it can be interpreted structurally rather than as part of a wordform. In addition, when an apostrophe separates alphabetic material on both sides, the implementation splits the string into two subtokens and marks the first as having no following space, capturing the orthographic attachment relevant for Italian clitics and elisions while maintaining a consistent notion of token boundaries.

Token-level validation enforces local well-formedness constraints. Each token must conform to the permitted character inventory and to the expected surface patterns for lexical forms or recognized Jefferson markers.

(\pL:*)+[-’]?[.,?]?

Tokens are then assigned to a category: short pauses, nonverbal behaviours, unintelligible tokens and lexical items are the main labels. Multiword non-verbal behaviors are concatenated in our pipeline using an underscore (e.g., ((risata_lunga))) in order to prevent internal tokenization and to retain them as single tokens in the final representation.

Prosodic information encoded on token characters is systematically extracted and represented as structured features. Final punctuation (i.e., ., , and ?) determines intonational contour categories; interruption symbols (' or -) signal truncation; colon sequences encode vowel prolongation; capitalization is interpreted as a marker of increased volume and normalized in the lexical representation. In each case, the surface marker is separated from the underlying lexical form while preserving its interpretive value as a feature of the token.

After tokenization, span information is projected onto tokens. Character-level spans identified at the previous stage are mapped onto the tokens they cover, and the relevant token-internal character ranges are recorded. This allows, for example, for a low-volume or fast-paced span to be associated precisely with the lexical material it affects, even when spans cut across token boundaries.

The result of token-level validation is a sequence of tokens that are locally well-formed, categorically typed, and enriched with prosodic and interactional features derived from the Jefferson surface notation.

Each token was assigned a unique identifier derived from the TU and its position within it, ensuring traceability back to the original source.

3.4 Integrating the three levels

The three layers provide an explicit operationalization of Jefferson-style transcription. Without attempting to “validate Jefferson” as a whole, the pipeline validates a declared analytical model: TUs are time-aligned speaker segments with normalized annotation strings; spans are balanced and extractable realizations of selected Jefferson devices; and tokens are locally well-formed units combining lexical identity with structured prosodic features. This layered design preserves the descriptive richness of Jefferson notation while enabling reproducible conversion. A central robustness criterion is round-trip stability: tokenization and serialization must reproduce a canonical version of the transcript (modulo formatting normalization). This constraint ensures that the induced grammar is internally coherent and that no information is lost or ambiguously represented. In the vertical format (Figure 6), each token occupies a single row enriched with speaker, structural, alignment, and linguistic attributes (the full specification is given in Table 3), making it possible to query lexical, interactional, and metadata dimensions jointly: capabilities not available in the original transcription-based representation.

Figure 6

All span-like features and character-based phenomena are represented using explicit character offsets relative to the normalized orthographic form of each token. Temporal alignment from ELAN is preserved without redundancy: timestamps are anchored to the first and last token of each TU, allowing deterministic reconstruction of time-aligned units while keeping alignment conceptually tied to the unit rather than individual words. Interactional and prosodic phenomena that apply to subtoken segments are encoded through explicit character offsets relative to the normalized token form. This character-level anchoring maintains fine-grained correspondence with the original Jefferson string and guarantees faithful round-trip reconstruction.

Over time, this verticalized representation has evolved from an intermediate export into the authoritative pivot format of the corpus. Instead of treating ELAN files as the primary artefact and generating derivative formats ad hoc, the workflow now centers on the pivot representation, from which ELAN files and other task-specific formats can be regenerated reproducibly (Figure 7). Crucially, the architecture is bidirectional: updates or corrections applied at the pivot level propagate to derived formats, and new annotation layers can be aligned back to the core representation. This enables updates, corrections, or enrichments introduced at one level to propagate across representations, reducing divergence and duplication. This projection-based approach mitigates a common problem in corpus development, namely the proliferation of partially incompatible versions of the same data.

Figure 7

From a maintenance perspective, centralizing development around the verticalized format has led to tangible benefits. Versioning, validation, and consistency checks can be performed at a single point, simplifying long-term corpus management. This has proven particularly valuable in the context of a modular corpus such as KIParla, where new data are periodically added and existing modules may require revision.