Legacy JavaScript systems lack type safety, making maintenance risky. While TypeScript can help, manually adding types is expensive. Previous automated typing research focuses on type inference but rarely addresses type checking setup, definition generation, bug identification, or behavioral correctness at repository scale. We present AgenticTyper, a Large Language Model (LLM)-based agentic system that addresses these gaps through iterative error correction and behavior preservation via transpilation comparison. Evaluation on two proprietary repositories (81K LOC) shows that AgenticTyper resolves all 633 initial type errors in 20 minutes, reducing manual effort from one working day.
Figures & tables
Figure 1. Three-phase typing approach. A flowchart diagram showing three sequential phases for automated typing. Phase 1 (Minimal Setup) includes enabling TypeScript, installing missing types packages, and fixing or suppressing type errors. Phase 2 (Full Coverage) enables noImplicitAny, adds definitions and annotations, and addresses new errors. Phase 3 (Strict Mode) enables strict mode, refactors for type safety, and performs regression testing. Thick arrows connect the phases sequentially.
Figure 2. Single-agent architecture for phase one and two. The hook preventing behavior changes is highlighted. A flowchart showing the workflow of a single agent. Starting from a code file at the top, errors flow to a coding agent. A hook triggers on file edits and sends back transpiled diff via a red dashed feedback arrow if there are any changes. When the agent finishes, a verification step is executed. If remaining errors exist, a red dashed feedback arrow returns to the agent. On success, the flow completes with a checkmark.
Repo
LOC
Type Errors
Necessary Suppressions
Additional Suppressions
Time
Cost
A
75K
570
327
+26 (+8.0%)
16:51 min
$22.85
B
6K
63
56
+0 (+0.0%)
3:06 min
$2.08
Total
81K
633
383
+26 (+6.8%)
19:57 min
$24.93
Table 1. Phase one results on two proprietary JavaScript repositories. Average of three runs each.
Linguistic typology relies on expert analysis of reference grammars across languages, making large-scale crosslinguistic comparison labor-intensive and unscalable. We introduce AUTOTYPOLOGIST, an LLM agent for evidence-grounded typological analysis over reference grammars. The agent is capable of retrieving relevant grammar sections, analyzing interlinear glossed text (IGT), and iteratively reasoning over typological hypotheses using a ReAct-style workflow. We evaluate the system on TYPOLOGICAL FEATURE CODING against expert annotations and TYPOLOGICAL HYPOTHESIS TESTING with typological universals using 25 open-source reference grammars. Operating under different information constraints in TYPOLOGICAL FEATURE CODING, the agent can synthesize information from reference grammar prose but still faces challenges with only IGTs in the target language. In TYPOLOGICAL HYPOTHESIS TESTING, the agent can synthesize crosslinguistic evidence and identify both supporting cases and counterexamples. These findings suggest that LLM agents can support scalable and inspectable typological analysis, while still requiring expert validation.
Changbing Yang, Christopher Hammerly, Freda Shi +1
University of British Columbia · University of Waterloo · Vector Institute
Language model (LM) agents have driven substantial progress in automated software engineering (SWE), yet building and testing software repositories at scale remains a largely manual and labor-intensive bottleneck. In this work, we introduce RepoLaunch, a novel agentic framework that automatically resolves dependencies, compiles source code, and extracts test results across diverse programming languages and operating systems. RepoLaunch achieves a 78% build success rate, outperforming the Python/Linux-only prior system by 18%. To demonstrate its application, we further present a fully automated pipeline for SWE dataset creation driven by RepoLaunch, which only requires human input at the task-design stage. RepoLaunch is open-sourced, and its automated task-generation pipeline has been adopted by several recent works on agentic benchmarking and training.
We ran 300 repeated vulnerability-finding scans to measure how repeatable agentic large language model (LLM) security review is on the same JavaScript code, prompt, and benchmark harness. The headline result is that LLM security findings were unevenly repeatable: reference-matched findings were stable, but extra model reports varied heavily from run to run. Across 250 model runs, 80 of 161 unique unmatched findings appeared in only one of five identical repetitions, while only 22 appeared in all five. By contrast, when Claude matched a Snyk Code reference finding, the behavior was much more stable: 134 of 158 unique reference-matched findings appeared in all five repetitions. The benchmark also shows complementarity. Models consistently found familiar, high-signal exploit shapes, and in one case surfaced a likely Snyk Code product gap. Snyk Code static application security testing (SAST) was deterministic and better at systematically enumerating repeated data-flow sinks. The results support combining agentic LLM review with deterministic SAST rather than treating either technique as a replacement for the other.