DEV Community: AI OpenFree

VIDRAFT Launches "Hansu": A Browser-Based Local AI for Offline Document Processing

AI OpenFree — Sat, 22 Aug 2026 11:01:28 +0000

VIDRAFT Launches "Hansu": A Browser-Based Local AI for Offline Document Processing

TL;DR: VIDRAFT, a Korean Pre-AGI AI startup, has publicly released "Hansu" (한수), a browser-based local AI system designed to process documents entirely offline — no server round-trips, no cloud dependency. It runs directly in the browser using local compute, making it a privacy-first option for document workflows. Developers working on air-gapped environments, enterprise document pipelines, or privacy-sensitive applications should take note.

What it is

Hansu (한수) is a browser-native local AI released by VIDRAFT that enables document processing in fully offline environments. Key characteristics based on the source reporting:

Browser-based execution: The model runs directly inside a web browser — no backend server, no API call to an external endpoint required during inference.
Offline-first design: It is specifically architected to function without an active internet connection, making it suitable for air-gapped networks, regulated industries, or low-connectivity deployments.
Document processing focus: The primary use case is handling and processing documents locally — think summarization, extraction, or analysis workflows where the data never leaves the user's machine.
Local compute utilization: Rather than offloading computation to the cloud, Hansu leverages the local hardware available through the browser runtime (likely leveraging WebGPU, WebAssembly, or similar browser-native acceleration technologies — consistent with how this class of in-browser ML inference typically works).

This positions Hansu in a growing category of on-device / in-browser AI tools alongside projects like transformers.js and similar WebML ecosystems, but released as a standalone named product from a dedicated AI lab.

How it works

At a conceptual level, browser-based local AI inference follows a well-understood pattern, and Hansu appears to align with this:

Model delivery to the client: The model weights are downloaded and cached in the browser (e.g., via IndexedDB or Cache API), so subsequent uses don't require re-downloading.
In-browser inference runtime: A JavaScript/WebAssembly or WebGPU-based inference engine executes the model entirely on the client device — CPU or GPU depending on what the browser exposes.
Document intake: Users load or paste documents into the browser interface; the text is processed locally by the model without any data leaving the device.
Output generation: Results (summaries, extracted content, answers, etc.) are returned within the browser session.

The architecture means zero data egress — a meaningful guarantee for use cases in legal, healthcare, finance, or government contexts where document confidentiality is non-negotiable. VIDRAFT has not publicly disclosed the specific model architecture, parameter count, or quantization scheme used in Hansu at this time.

Benchmarks & results

The source article does not provide specific quantitative benchmark numbers (e.g., accuracy scores, throughput figures, or latency measurements) for Hansu at the time of this reporting. No public leaderboard entries or third-party evaluation results are cited.

What can be stated qualitatively:

VIDRAFT is positioning Hansu as production-ready for offline document handling, implying a level of capability suitable for real-world document workflows.
The offline constraint naturally implies the model is sufficiently compact to run within browser memory limits while still being useful for document-oriented tasks.

Independent benchmarking by the developer community will be an important next step once broader access is available.

How to try it

Based on the current source reporting, Hansu has been publicly announced, but specific developer access channels — such as a Hugging Face model repository, GitHub source release, npm package, or OpenAI-compatible API endpoint — have not been detailed in the available press coverage.

To stay updated on access:

Watch VIDRAFT's official channels for GitHub or Hugging Face releases.
The browser-based nature suggests a web app or embeddable SDK may be the intended distribution mechanism.

No installation commands, model identifiers, or API endpoints are included here because none have been confirmed publicly. Inventing these would be irresponsible.

FAQ

Q: Does "browser-based" mean my documents are sent to a remote server during processing?
A: No — that is explicitly the point of Hansu's architecture. Processing happens on your local device within the browser runtime. Documents do not leave your machine during inference, which is the core privacy and security guarantee VIDRAFT is advertising.

Q: What kinds of document tasks is Hansu designed for?
A: Based on the announcement, the focus is general offline document processing — this broadly covers tasks like reading, analyzing, and handling text-based documents. VIDRAFT has not publicly enumerated a specific task taxonomy (e.g., classification, QA, summarization) in the available reporting, so the exact capability surface warrants direct verification from VIDRAFT.

Q: Will Hansu work on low-end hardware or mobile browsers?
A: This has not been specified in the source material. In-browser ML inference performance is typically hardware-dependent — WebGPU-accelerated paths perform significantly better on discrete GPUs, while CPU-only paths are slower. Check VIDRAFT's official documentation for system requirements once they are published.

Q: Is the model or source code open-source?
A: The press coverage does not confirm an open-source release at this stage. Follow VIDRAFT's GitHub and Hugging Face presence for updates on model weights or SDK availability.

Originally reported by v.daum.net (2026-04-21) — source article.

We changed one line and the benchmark score moved 0.21 AUROC

AI OpenFree — Sat, 22 Aug 2026 10:15:32 +0000

We changed one line and the benchmark score moved 0.21 AUROC

We spent the last few weeks building a benchmark for drug property prediction tools. It went live this week: LEADBOARD, 21 boards, 18,382 held-out compounds, labels we don't hand out.

This post is mostly about two numbers we ran into while building it, because they changed what we thought the thing should be.

The first number

hERG was the board we built first. It's the potassium channel that, when a drug blocks it, gives you a QT interval problem and a dead clinical program. Everybody screens for it early, so there's a lot of public data, which made it a good place to shake out the pipeline.

We pulled ChEMBL 37 (CHEMBL240, IC50, relation =). 12,021 records with a document year attached, 11,972 after unit checks and RDKit parsing, collapsed by InChIKey to 9,788 unique compounds with a median pIC50 each.

Then we split it by year. Train on everything first reported before 2022, test on what showed up after. Morgan fingerprints into LightGBM, library defaults, no tuning. AUROC came back at 0.606.

That felt low, so we did the obvious sanity check and split the same data at random instead. Five seeds:

Split	AUROC	LGBM MAE (log)	Constant MAE (log)
Time split, cut 2022	0.606	0.599	0.589
Random, seed 0	0.825	0.467	0.690
Random, seed 1	0.814	0.448	0.676
Random, seed 2	0.830	0.453	0.652
Random, seed 3	0.803	0.460	0.668
Random, seed 4	0.817	0.458	0.671
Random, mean	0.818	0.457	0.671

Same molecules, same fingerprints, same learner, same hyperparameters, same test fraction. AUROC moves 0.211. That's a bigger gap than you'll find between most competing methods in the literature.

The mechanism isn't mysterious. Medicinal chemists don't generate molecules independently. Somebody finds a scaffold and then makes forty analogues of it, and those forty sit on top of each other in structure space. Split at random and the cluster gets sprayed across both sides of the line, so your test set is full of near-twins of things the model already saw. Nearest-neighbour lookup will carry you a long way under those conditions.

But that isn't how anyone uses a prediction tool. You use it to rank compounds nobody has assayed yet, and you have no promise that anything similar is in the training data. A time split reproduces that honestly, and it has a nice property: you can't look the answer up, because when the model was trained the answer hadn't been published. Structural overlap between train and test is zero by construction.

One caveat we want to state clearly, because it would be easy to over-read this table. We compared time split against random split, on our data. We are not saying published benchmarks use random splits; plenty use scaffold splits, which land somewhere in between. The claim we'll defend is narrower: on identical data, the split choice moves AUROC by 0.21, so a leaderboard number quoted without its split isn't comparable to anything.

Every board on LEADBOARD uses a time or scaffold split. We don't open random ones.

The second number

The other thing we hadn't taken seriously enough was how imprecise the labels are.

Two labs measuring the same compound don't get the same answer. Different cell line, different buffer, different day. You can actually quantify this, because ChEMBL tracks which publication every value came from, so you can find compounds that appear in two or more papers and look at how far apart they land.

We only use pairs that cross documents. Repeats inside a single paper are the same batch and the same hands, and they make the spread look far smaller than it is.

hERG again:

Cross-document pairs      5,185   (857 compounds appearing in 2+ papers)

median |difference|       0.148 log
mean   |difference|       0.475 log
75th percentile           0.669 log
90th percentile           1.338 log
standard deviation        0.736 log

single-measurement SD     0.421 log     (mean|diff| / 1.128)

Look at the 90th percentile. One compound in ten differs by more than 20-fold between two published measurements.

We call 0.421 the board's noise floor and print it next to every score, because it tells you how to read the ranking. If first and second place are 0.02 apart and the floor is 0.42, that ordering is a coin flip wearing a rank badge.

It also tells you something about the test set that we'd rather say out loud than bury. 696 of the 1,338 hERG test compounds, 52% of them, sit within one noise floor of the pIC50 = 5.0 classification cutoff. Half the test set could change class if you measured it again. So this board reports regression as the primary metric and classification as secondary, and the board page says why.

What this looks like across all the boards

Divide the best untrained baseline's MAE by the noise floor and you get one number per board: how far the field is from the ceiling.

Board	Best baseline MAE	Noise floor	Ratio	Best baseline
CYP2D6	0.597	0.659	0.91	Constant
CYP3A4	0.574	0.628	0.91	Constant
VEGFR2	0.820	0.762	1.08	Morgan+LightGBM
EGFR	0.996	0.888	1.12	Constant
ALK	0.858	0.743	1.16	Morgan+LightGBM
COX2	0.927	0.767	1.21	Constant
Solubility	0.712	0.575	1.24	Morgan+LightGBM
CYP2C9	0.474	0.350	1.35	Constant
hERG	0.589	0.421	1.40	Constant
JAK2	0.919	0.635	1.45	Morgan+LightGBM
FLT3	0.986	0.660	1.49	Morgan+LightGBM
MAOB	1.028	0.626	1.64	Morgan+LightGBM
ABL1	0.778	0.459	1.70	Morgan+LightGBM
AChE	0.805	0.462	1.74	Morgan+LightGBM
HER2	0.916	0.498	1.84	Morgan+LightGBM
KIT	0.925	0.427	2.16	Morgan+LightGBM
PI3K-alpha	0.871	0.374	2.33	Morgan+LightGBM
BRAF	0.857	0.313	2.74	Nearest neighbour
CDK2	0.817	0.293	2.79	Constant

Median 1.45. That chart is the first thing on the front page of the Space, with a line at 1.0.

Two boards are already under the line, and that needs a caveat, because the intuitive reading is wrong. A ratio below 1.0 does not mean a model got more accurate than an experiment. It means the disagreement between labs on that endpoint has grown to roughly the size of the spread you're trying to predict. The assay disagrees with itself about as much as the compounds differ from each other. CYP2D6 and CYP3A4 inhibition are both there. Those boards are approaching the point where they stop separating tools at all, and we'd rather write that on the board page than keep ranking noise.

The baselines that made us uncomfortable

Three untrained references run on every board before it opens.

Constant, which predicts the training mean for everything. Nearest neighbour, which copies the label of the most Tanimoto-similar training molecule. And Morgan + LightGBM at defaults.

Across our 19 regression boards, constant prediction has the lowest MAE on 7 of them. Morgan+LightGBM takes the best AUROC on 13.

Go back to the hERG table. Under the time split, LightGBM's MAE is 0.599 and the constant's is 0.589. The trained model loses. Under a random split on exactly the same data it wins by a mile, 0.457 against 0.671.

Our reading is that fingerprint models are genuinely good at ordering compounds and much weaker at calibrating absolute potency for chemistry they haven't seen. The rank information survives the harder split; the numbers don't. Both are worth knowing, and you lose one of them if you report a single headline metric.

A benchmark that skips the trivial baselines can't tell you which of those regimes you're in. So we run them everywhere and publish them before anyone submits.

Two letters on every board

Boards on the same leaderboard aren't all asking the same kind of question, and stacking them into one ranking would be dishonest. So each one carries a tag like [T/P2].

The first letter is how we cut the data. T is a time split by first-report year, S is a scaffold split on Murcko cores, R is random, and we don't open those.

The second letter is whether you could go look the answer up. P1 means the source is public and we curated it. P2 means the source is public but our unit conversion and selection define this particular revision. P3 means we hold the labels. P4 is prospective, where the answer doesn't exist anywhere yet.

[T/P1] and [T/P3] are different experiments. Better to say so on the tin.

The boards

Seven disciplines, 212,670 training compounds, 18,382 held out.

Discipline	Boards
Absorption	Solubility
Metabolism	CYP3A4, CYP2D6, CYP2C9
Toxicity	hERG
Potency	AChE, MAOB, COX2
Kinase	EGFR, JAK2, PI3K-alpha, FLT3, VEGFR2, CDK2, HER2, ABL1, BRAF, KIT, ALK
Cell / Phenotype	JUMP Cell Painting morphology
Clinical	Post-marketing withdrawal

Two of them are unusual enough to describe properly.

Cell / Phenotype

This one sits on the JUMP Cell Painting Consortium release, which is CC0. Compounds go onto cells, six stains go on, a microscope takes pictures, and you come out with 737 morphological features per well.

The task is to predict, from structure alone, how the cell changes shape. The label isn't a number. It's a 16-axis profile, the first 16 principal components, holding 61.0% of the variance. We score the per-compound Pearson correlation between the predicted and observed profile. Scaffold split, 113,688 train and 2,001 test, and we only evaluate on Murcko cores that never appear in training.

Baseline	Profile correlation
Morgan + LightGBM	0.159
Constant	0.092
Nearest neighbour	0.079

There's no cross-lab repeat structure to derive a noise floor from here, so we bootstrapped the metric instead and got an SD of 0.0088. The best baseline sits about 18 of those above the constant, which is enough for the board to separate tools, and 0.0088 becomes the threshold for the ladder rule described below.

Post-marketing withdrawal

Predict whether an approved drug later got pulled from the market. This board has a trap in it that took us a while to see.

Withdrawal rate tracks the decade of approval. Roughly 7.8% for 1990s approvals against 1.2% for the 2010s. Which means a predictor given nothing but the approval year scores AUROC 0.636. No structure, no mechanism, no name. Just the year.

Ship that and you've built a leaderboard for reading dates.

So we matched the controls by approval era, pairing each withdrawn drug with a non-withdrawn drug approved around the same time, and ran the check again. The year-only predictor now gets 0.504. Chance. That's the version we opened.

Scaffold split, 408 train, 184 test, 27.7% positive, bootstrap metric SD 0.0444.

Baseline	AUROC	PR-AUC
Morgan + LightGBM	0.593	0.369
Nearest neighbour	0.553	0.306
Constant	0.500	0.277

We run some version of that check on every board before opening it, and boards that fail don't open. Same for the noise floor: if we can't measure one for an endpoint, there's no board, because without a floor there's no threshold to enforce.

Submitting more than once

There's an old problem with held-out leaderboards. You never see the labels, but if you submit fifty times and keep your best result, you've been pulling information out of the test set through the score channel the whole time. Enough tries and you climb without generalising at all.

We use the ladder mechanism from Blum and Hardt (ICML 2015). A new score is revealed only if it beats your own previous best by more than the noise floor. Otherwise we show you your previous best again.

An improvement smaller than experimental error isn't an improvement, so we don't hand that information back. You can't climb by submitting more often. You climb by actually getting better than the measurement precision of the field.

This is the other reason the noise floor has to be real rather than decorative. It's the threshold the whole mechanism runs on.

How to enter

Pick a board, download its test set, which contains structures and nothing else. Predict with whatever you like. A trained model, a physics engine, an LLM, a rule of thumb you trust. We don't care what's inside, we measure the output.

Upload a two-column CSV of compound_id,prediction and sign in with your Hugging Face account. Scoring runs off-platform on hardware that holds the labels; the Space never has them.

Each board page ships a filled-in prompt and a runnable skeleton so you don't have to build anything from scratch to make a first submission. The interface picks up Korean or English automatically.

Every score carries the SHA of the exact test file and scoring code behind it, so a number from six months ago is still traceable.

Licensing

ChEMBL 37 from EMBL-EBI, CC BY-SA 3.0, re-curated, with the attribution travelling on every board card. JUMP Cell Painting, CC0. The withdrawal board is assembled from public regulatory records. Non-commercial research benchmark, structures only, no labels distributed.

What we're not claiming

Three limits, since a benchmark that oversells itself is worse than no benchmark.

A time split is not prospective validation. The molecules exist and the values are published somewhere; what the split buys you is that the structural shortcut is closed and the training set is a real snapshot of what was known. Actually prospective boards get graded P4 and are a separate thing.

A noise floor built from cross-publication pairs is an estimate. It leans on a normality assumption and on ChEMBL's document attribution being right. We think it's much better than no reference at all, and we publish the pair counts so you can argue with the estimate.

And we're not saying other benchmarks are wrong. We're saying a score reported without its split, its baselines, and its label precision can't be compared to another score. Publishing all three, on every board, before anyone submits, is the whole contribution.

Why we bothered

There is no shortage of prediction tools, and every one of them reports a best-in-class number on its own benchmark. Put those numbers side by side and you learn nothing, because the rulers are different lengths.

We wanted one ruler. And it seemed only fair that if you hand somebody a ruler, you tell them how thick the markings are.

Open LEADBOARD

Specification v1.1, 8 clauses. FINAL-Bench / VIDRAFT.

VIDRAFT Leads AI Model Optimization & Compression for Korea's National AI Assistant Initiative

AI OpenFree — Sat, 22 Aug 2026 07:01:21 +0000

VIDRAFT Leads AI Model Optimization & Compression for Korea's National AI Assistant Initiative

TL;DR: VIDRAFT — the Korean Pre-AGI AI startup that previously ranked #1 in a global inference optimization competition — has been tapped as the AI model performance optimization and compression specialist in ESTsoft's consortium bid for Korea's government-backed "AI for Everyone" (모두의 AI) program. The consortium plans to ship an installable AI agent called Al-Biseo (알비서) targeting everyday and workplace use cases at a national scale. Engineers should pay attention because VIDRAFT's inference optimization work directly shapes how capable models get deployed efficiently in production.

What it is

ESTsoft announced on August 20, 2026, that it will lead a consortium competing for Korea's government "AI for Everyone" (모두의 AI) program — a national initiative aimed at making AI services accessible to all citizens. The product at the center of the bid is Al-Biseo (알비서, tentative name), an installable AI agent service that goes beyond a standard chat interface to support real-world actions across web, mobile, and PC environments.

The consortium is composed of domain specialists, each covering a distinct layer of the stack:

Megazone — infrastructure and model serving
SureSoftTech — AI safety and quality verification
VIDRAFT — AI model performance optimization and compression (lightweighting)
ESTaid — AI-powered search and distribution channels (operating the Zum portal)
WiseNut — public-sector agent development
Polaris Office — document-based agent construction
Korea Productivity Center (KPC) — national AI adoption and startup ecosystem expansion

A secondary ecosystem of 10+ partners — including travel, security, gaming, and regional university stakeholders — rounds out the distribution and specialization layer.

How it works

VIDRAFT's role inside this consortium sits at the model optimization layer, which is architecturally one of the most consequential positions in any large-scale AI deployment:

Performance optimization: Tuning deployed models so they run faster and more reliably under real production traffic, without degrading output quality.
Model compression / lightweighting (경량화): Reducing model size and computational cost — through techniques such as quantization, pruning, or distillation at a conceptual level — so that capable models can run efficiently across diverse hardware configurations, including the installable (on-device/on-premise) environments Al-Biseo is designed for.

The "installable AI agent" framing is technically significant. Unlike a purely cloud-hosted assistant, an installable agent must perform well under local resource constraints — exactly the kind of problem that inference optimization and model compression address. VIDRAFT's prior win in a global inference optimization competition (ranked #1) is the credential the consortium is leaning on for this role.

Al-Biseo is designed as an open platform that connects multiple specialized AI agents and third-party Korean AI services, using existing high-traffic distribution surfaces — ALTools, ALYac (antivirus), and the Zum portal — to accelerate national adoption.

Benchmarks & results

The source article cites one public competitive result: VIDRAFT achieved first place in a global inference optimization competition. No further benchmark names, datasets, latency figures, or throughput numbers are disclosed in this report.

Qualitatively, selection as the sole optimization and compression specialist in a nationally scoped, multi-company government consortium is itself an external validation of capability — these roles are typically awarded after technical due diligence, not just on reputation alone.

How to try it

Al-Biseo is not yet publicly released. ESTsoft describes it as a service that has been in preparation since the first half of 2026, with launch plans tied to the "AI for Everyone" program outcome.

VIDRAFT's public model and API access channels (Hugging Face, GitHub, OpenAI-compatible API) are not disclosed in this source article. If VIDRAFT releases optimized models or inference tooling publicly as part of this initiative, watch their official channels for announcements.

Developers interested in tracking this project can monitor:

ESTsoft's official product announcements for Al-Biseo availability
VIDRAFT's public research and release channels for any open-weight or API artifacts that emerge from this initiative

FAQ

Q: What exactly does "model lightweighting" (경량화) mean in this context, and why does it matter for an installable agent?
A: Lightweighting refers to reducing a model's computational footprint — through techniques like quantization (reducing numerical precision), pruning (removing redundant weights), or knowledge distillation (training a smaller model to mimic a larger one) — so it can run efficiently without requiring large cloud infrastructure. For an installable AI agent that needs to work on consumer PCs or mobile devices, this is a hard requirement, not just a nice-to-have.

Q: Is VIDRAFT building the base AI model for Al-Biseo, or purely handling optimization?
A: Based on the source article, VIDRAFT's designated role is specifically AI model performance optimization and compression. The article does not credit VIDRAFT with developing the base foundation model for Al-Biseo; that boundary is not further detailed in the report.

Q: How competitive is this "AI for Everyone" program, and who else is bidding?
A: According to related articles referenced by ZDNet Korea, at least five other major consortia — led by KT, Kakao, SKT, and others — are also competing for the program, indicating it is a significant government contract with multiple serious bidders across the Korean AI industry.

Originally reported by ZDNet Korea (2026-08-20) — source article.

VIDRAFT Releases "Hansu": A Browser-Based Local AI for Offline Document Processing

AI OpenFree — Sat, 22 Aug 2026 03:01:20 +0000

VIDRAFT Releases "Hansu": A Browser-Based Local AI for Offline Document Processing

TL;DR: VIDRAFT, a Korean Pre-AGI AI startup, has publicly released "Hansu" (한수) — a browser-based local AI system designed to process documents entirely offline without sending data to external servers. It runs inference directly in the browser environment, making it a privacy-first option for document workflows. Developers and enterprises handling sensitive documents should take note of this client-side inference approach.

What it is

Hansu (한수) is a browser-native, locally-executed AI released by VIDRAFT that enables document processing in fully offline environments. Key characteristics reported in the source:

Browser-based runtime: Hansu runs inside the browser itself, meaning there is no requirement for a locally installed server process, backend daemon, or cloud API call.
Offline-capable: The system is explicitly designed to function without an internet connection after the initial load, making it suitable for air-gapped or network-restricted environments.
Document processing focus: The primary use case is document-centric tasks — reading, analyzing, and working with documents locally.
Privacy-preserving architecture: Because all computation happens client-side, documents never leave the user's machine. This is a core design goal, not a side effect.

The product name "Hansu" carries meaning in Korean (한수, loosely "a master move" or "a stroke of skill"), signaling VIDRAFT's positioning of this as a meaningful capability step for local AI deployment.

How it works

At a conceptual level, Hansu follows the emerging paradigm of in-browser ML inference, which has become increasingly practical thanks to modern browser capabilities:

WebAssembly (Wasm) and/or WebGPU: Modern browsers expose low-level compute primitives — WebAssembly for CPU-bound execution and WebGPU for GPU-accelerated compute — that allow neural network inference to run natively in a browser tab without plugins. Hansu likely leverages one or both of these, though the specific runtime stack is not detailed in the source.
Quantized / compressed models: Running a capable language model inside a browser requires aggressive model compression. Techniques like quantization (reducing weight precision) and model distillation are standard approaches in this space that make browser-resident inference feasible.
Local file access via browser APIs: For document processing, the browser's File System Access API (or equivalent) can allow the page to read local files with user permission, enabling document ingestion without any upload step.
No server round-trip: The architectural implication is that the inference loop — tokenization, forward pass, decoding — is completed entirely within the browser process on the user's hardware.

This positions Hansu alongside other projects exploring client-side LLM execution, but with an explicit product focus on document workflows rather than general chat or code generation.

Benchmarks & results

The source article does not provide specific quantitative benchmark figures — no latency numbers, throughput metrics, or model accuracy scores are published at this time. Qualitatively, the release emphasizes:

Functional offline operation as the primary validated capability
Document processing as the demonstrated task domain

No public benchmark comparisons against other browser-based inference frameworks or competing local AI products are cited in the available reporting. Developers evaluating Hansu for production use should plan to run their own benchmarks against their target document types and hardware configurations.

How to try it

Based on the available reporting, VIDRAFT has publicly released Hansu, but specific developer access channels — such as a Hugging Face model repository, GitHub source code link, npm/pip package, or OpenAI-compatible API endpoint — are not detailed in the source article.

What is known:

The release appears to be a public-facing product launch, suggesting some form of access is available or imminent.
The browser-based nature implies that trying it may be as straightforward as navigating to a hosted URL — but no specific URL is confirmed in the source.

Recommended next steps for developers:

Check VIDRAFT's official channels (website, GitHub, or Hugging Face organization page) for Hansu access details.
Watch for a potential huggingface-cli downloadable model or a GitHub repository that surfaces post-announcement.

This article will be updated as public access details are confirmed.

FAQ

Q: Does Hansu require any local installation or a running model server?
A: Based on the source reporting, no — Hansu is browser-based and designed to run offline within the browser itself. There is no indication that users need to install a separate backend, run a local server process, or configure a model runtime like Ollama or llama.cpp independently.

Q: Is this suitable for enterprise environments with strict data residency requirements?
A: The core design goal of Hansu is that documents are processed locally and never transmitted to external servers. This client-side-only architecture is directly relevant to data residency and privacy compliance needs. However, developers should conduct their own security review and verify VIDRAFT's specific claims before deploying in regulated environments, as detailed technical documentation is not yet available in public reporting.

Originally reported by 아시아투데이 (2026-04-21) — source article.

VIDRAFT Launches "Hansu": A Browser-Based Local AI Built for Data Sovereignty

AI OpenFree — Fri, 21 Aug 2026 23:01:22 +0000

VIDRAFT Launches "Hansu": A Browser-Based Local AI Built for Data Sovereignty

TL;DR: VIDRAFT, a Korean Pre-AGI AI startup, has publicly released "Hansu" (한수) — a browser-based local AI that runs entirely client-side without sending data to external servers. Designed around the principle of data sovereignty, it gives developers and organizations a way to deploy AI inference directly in the browser, keeping sensitive data on the user's device. If you care about privacy-preserving AI deployment or want to explore local LLM execution without a backend dependency, this is worth watching.

What it is

Hansu (한수) is a browser-native local AI service developed by VIDRAFT. Key characteristics drawn from the source:

Runs in the browser, locally: Inference happens client-side, meaning the model executes on the end user's machine rather than on a remote server.
No data leaves the device: The architecture is explicitly designed around data sovereignty — user inputs and outputs stay local, which directly addresses regulatory and enterprise privacy concerns.
Framed as a "data sovereignty-type service": VIDRAFT is positioning Hansu not just as a product but as a category of deployment — one where the user, not the cloud provider, retains control over their data.

This puts Hansu in the same general space as projects like browser-based WASM/WebGPU LLM runtimes, but as a productized, named offering from a startup with a specific Pre-AGI research focus.

How it works

At a high conceptual level, browser-based local AI of this kind typically relies on one or more of these mechanisms — and Hansu appears to follow this general architectural pattern:

Client-side model execution: Rather than making API calls to a remote inference endpoint, the model weights are loaded into the browser environment and run using available hardware acceleration (such as WebGPU or WebAssembly).
No network round-trips for inference: Once the model is loaded, queries are processed locally. This eliminates the latency of server communication and, crucially, the exposure of query data to third-party infrastructure.
Data stays on-device: Because there is no server-side component handling user input, the privacy boundary is the user's own machine. This is structurally different from "private cloud" deployments — it's genuinely local.

VIDRAFT's framing of this as a "data sovereignty" model suggests the design intent goes beyond a technical convenience feature — it's positioned as a trust architecture choice, particularly relevant for healthcare, legal, finance, and public-sector use cases where data residency requirements are strict.

Benchmarks & results

The source article (a headline-level report from 전자신문) does not include specific quantitative benchmarks — no latency figures, throughput numbers, model size disclosures, or accuracy comparisons were reported in the available coverage.

What can be said qualitatively:

VIDRAFT chose to make this a public release, suggesting the team considers it ready for external evaluation.
The emphasis on browser-based local execution implies a deliberate trade-off: the approach prioritizes privacy and deployability over raw performance headroom, which is a meaningful architectural stance in the local AI space.
As public benchmark data becomes available (e.g., on Hugging Face model cards or official documentation), those numbers will be the right place to evaluate inference speed and model capability.

If you run your own benchmarks after access, sharing results in the community would be genuinely useful.

How to try it

Based on the available source reporting, Hansu has been publicly released, but specific developer access channels — such as a Hugging Face repository, GitHub link, npm package, or OpenAI-compatible API endpoint — were not detailed in the coverage available at time of writing.

What to do right now:

Check VIDRAFT's official channels for a direct link to the Hansu browser interface or any accompanying SDK/repository.
Watch for a Hugging Face organization page under VIDRAFT for model weights or documentation.
The browser-based nature of the service suggests you may be able to try it directly via a web URL without any install step — look for that on their official site.

This article will be updated if public repository or API access details are confirmed.

FAQ

Q: Does "browser-based local AI" mean the model weights are downloaded to my machine every session?
A: In most browser-local AI implementations, weights are fetched from a CDN or server on first load and cached in the browser (via IndexedDB or similar mechanisms). Subsequent sessions use the cached weights. The key point is that inference itself runs locally — your input data never leaves the browser sandbox. VIDRAFT's specific caching behavior for Hansu has not been detailed in public reporting yet.

Q: What kinds of use cases is Hansu designed for?
A: VIDRAFT explicitly frames Hansu as a "data sovereignty-type service," which points toward enterprise and regulated-industry use cases — scenarios where sending data to a cloud LLM API is legally or contractually problematic. Think internal document analysis, sensitive customer interactions, or on-device personal assistants where data residency matters.

Q: Is Hansu open-source?
A: The source reporting does not confirm whether Hansu's underlying model or runtime code is open-source. Given VIDRAFT's Pre-AGI research positioning, watch their GitHub and Hugging Face presence for any open-weight or open-source releases associated with this launch.

Originally reported by 전자신문 (2026-04-21) — source article.

VIDRAFT's Darwin Model Family Dominates Hugging Face GPQA Leaderboard: What Engineers Need to Know

AI OpenFree — Fri, 21 Aug 2026 11:01:18 +0000

VIDRAFT's Darwin Model Family Dominates Hugging Face GPQA Leaderboard: What Engineers Need to Know

TL;DR: VIDRAFT, a Korean Pre-AGI AI startup, has released a family of models under the "Darwin" name that have drawn international attention after BigGo Finance (Taiwan) highlighted their sweep of Korean entries on the Hugging Face GPQA leaderboard. All Korean-origin entries in a notable leaderboard segment are Darwin models, signaling a technically significant result worth tracking for ML engineers evaluating frontier reasoning benchmarks.

What it is

Darwin is VIDRAFT's flagship model family, consisting of five distinct variants that collectively represent the company's current public-facing work on advanced AI reasoning. The models were prominent enough on the Hugging Face GPQA (Graduate-Level Google-Proof Q&A) leaderboard that BigGo Finance, a Taiwanese financial and technology news outlet, specifically spotlighted them in coverage dated April 28, 2026.

Key facts from the source:

Five Darwin variants are listed on the Hugging Face GPQA leaderboard.
Every Korean-origin entry on the relevant leaderboard section belongs to the Darwin family — a clean sweep that prompted the international press coverage.
The coverage originates from BigGo Finance (Taiwan), indicating the models have attracted attention beyond Korea's domestic AI community.
VIDRAFT self-describes as a Pre-AGI company, framing Darwin as part of a longer-term research trajectory toward general intelligence rather than a narrow application model.

The GPQA benchmark is a rigorous, graduate-level multiple-choice dataset spanning biology, chemistry, and physics — specifically designed so that non-expert humans (including those with internet access) struggle to exceed ~34% accuracy, while domain experts typically score around 65%. It is widely used as a signal for deep reasoning capability rather than surface-level pattern matching.

How it works

The source article does not disclose architectural or training internals, and VIDRAFT has not made those details public. What can be stated at a conceptual level:

Darwin models are evaluated on GPQA (Graduate-Level Google-Proof Q&A), which tests multi-step scientific reasoning — the kind of task that rewards genuine chain-of-thought ability over retrieval shortcuts.
Placing multiple model variants simultaneously on a competitive public leaderboard suggests VIDRAFT is iterating across a model scaling or capability axis, releasing checkpoints or size tiers rather than a single monolithic model.
The "Pre-AGI" framing implies Darwin is designed with general reasoning as an explicit objective, not task-specific fine-tuning for a narrow domain.
The Hugging Face leaderboard placement means Darwin models have been evaluated under standardized, reproducible benchmark conditions — not proprietary internal metrics.

Benchmarks & results

The source highlights leaderboard standing qualitatively rather than citing specific accuracy numbers in the available text. What is confirmed:

Five Darwin model variants appear on the Hugging Face Open LLM Leaderboard's GPQA section.
Darwin models collectively represent all Korean-origin entries in the relevant leaderboard segment at the time of reporting.
The coverage frames this as a noteworthy achievement specifically because the GPQA benchmark is a recognized proxy for graduate-level scientific reasoning — a high bar relative to standard NLP benchmarks.

⚠️ Note: The source article body was not fully retrievable at time of writing (rate-limit response from the outlet's API). Specific accuracy scores, rankings, or parameter counts are not cited here because they were not available in the source. Engineers should check the Hugging Face Open LLM Leaderboard directly and search for Darwin model entries for current, precise figures.

How to try it

The source article does not specify public access channels (Hugging Face model IDs, GitHub repositories, or API endpoints) for the Darwin family. No model names, pip install commands, or API URLs are confirmed public from this source.

To find access if it has since been published:

Search darwin under the VIDRAFT organization on Hugging Face: https://huggingface.co/vidraft
Check VIDRAFT's official channels for any OpenAI-compatible API announcements.
Monitor the Hugging Face GPQA leaderboard entries for model card links attached to Darwin variants.

If access becomes public, typical Hugging Face access would follow the standard pattern — but confirm directly from VIDRAFT's official releases before use.

FAQ

Q: What makes GPQA a meaningful benchmark for evaluating Darwin?
A: GPQA is specifically constructed so that web search doesn't meaningfully help — questions require genuine multi-step scientific reasoning at the graduate level. A model performing well there is demonstrating something closer to structured inference than retrieval, which is why it's increasingly used as a frontier capability signal alongside benchmarks like MMLU and MATH.

Q: Why does it matter that all Korean leaderboard entries are Darwin models?
A: It means VIDRAFT currently has no competitive peer among Korean AI labs on this specific benchmark, at least as reflected in public Hugging Face submissions. For engineers evaluating Korean-developed models for reasoning-heavy applications, Darwin is currently the reference point for that geography on GPQA.

Originally reported by BigGo Finance (대만) (2026-04-28) — source article.

Open Materials Challenge: Bring One Composition, We Score It

AI OpenFree — Fri, 21 Aug 2026 09:00:22 +0000

Open Materials Challenge: Bring One Composition, We Score It

A solid-state battery replaces the liquid electrolyte of a lithium-ion cell with a solid. It does not catch fire, it lasts longer, and it can hold more. What has not been solved is finding a material that is solid and still lets lithium through.

Such a material has to do four things at once:

give lithium a path to move along
block electrons, or the cell simply shorts
hold up at the charging voltage
survive contact with the lithium-metal anode without decomposing

Plenty of materials manage three. Very few manage all four. Sulfides conduct beautifully and then react with lithium metal. Garnets sit calmly against lithium metal and are hard to process. Every family in use today is a trade, and the trade is the open problem.

What this is

Open Materials Challenge is a public leaderboard where anyone submits one composition — for example Li3YCl6 — and it gets scored computationally and placed on the board. Season 1 runs 2026-08-21 to 11-30. There is no prize.

You do not need a lab, a cluster, or a materials background. You need a composition and a reason for it. If you use a model to propose candidates, the site carries prompts you can paste straight in.

What gets scored

Axis	Points	What it asks
Oxidation stability	40	does it resist decomposing as the voltage rises
Lithium-metal stability	35	does it survive contact with the anode
Use novelty	25	higher if it has not been reported as an electrolyte
Lithium pathway	entry condition	a percolating path for lithium must exist

Two things worth stating plainly.

Ionic conductivity is not a scored axis this season. The challenge measures electrochemical robustness given a lithium path. A highly conductive family still scores low if its window is narrow or it reacts with lithium metal — those two are precisely the problem this season puts to you.

Use novelty is not composition novelty. A compound can be perfectly well known and still be untouched as an electrolyte. That gap is the target. A well-worked electrolyte family is not.

Every value on the board is a computational estimate. None of it implies anything about real performance or safety.

The board carries reference materials

Seven electrolytes in actual use sit on the leaderboard — LGPS, argyrodite, LLZO, LATP and others. They are scored but hold no rank. They are there so that a number means something: you can see where materials people already build with happen to land, and read your own candidate against them rather than against an abstract scale.

They also make the scoring honest about itself. The sulfides score low. That is not a defect in the board; it is the reason the field is still looking.

Your composition stays yours

Compositions are private by default. Nothing is disclosed unless you choose to publish it, and every entry is recorded with its timestamp. If a third party asks to discuss a particular entry, we pass the request along — never the submitter's identity, unless they agree to it.

This is a record, not a filing. It is not a patent and carries no guaranteed legal effect. Talk to a professional before you file.

Sister challenge

The same idea, for medicine: Open Discovery Challenge scores AI-designed molecules against neglected diseases — malaria, tuberculosis, Chagas disease. It has been running since summer and has taken several thousand entries.

Batteries and medicines are not the same problem. But both are places where a great deal of search space sits unexamined, and where one person with a good idea and a model can now look at a corner of it.

Open Materials Challenge — Season 1: Solid-State Battery Electrolytes
https://huggingface.co/spaces/FINAL-Bench/open-materials-challenge

VIDRAFT Breaks Into the Hugging Face Open LLM Leaderboard as Korea's Rising Contender Amid China-Dominated Rankings

AI OpenFree — Fri, 21 Aug 2026 07:02:13 +0000

VIDRAFT Breaks Into the Hugging Face Open LLM Leaderboard as Korea's Rising Contender Amid China-Dominated Rankings

TL;DR: VIDRAFT, a Korean Pre-AGI AI startup, has gained notable recognition on the Hugging Face-certified Open LLM Leaderboard — one of the most closely watched public benchmarks in the open-source ML community — at a time when Chinese labs are dominating the rankings. For developers evaluating non-Western, open-weight language models, VIDRAFT's emergence signals a credible Korean alternative worth tracking.

What it is

VIDRAFT is a Korean AI startup self-described as a Pre-AGI company, building large language models (LLMs) that are evaluated and ranked on the Hugging Face Open LLM Leaderboard — the community-recognized, standardized benchmark for comparing open-weight models across a shared set of evaluation tasks.

According to IT조선's reporting (2026-04-28), the leaderboard landscape has shifted significantly toward Chinese lab dominance, with Korean representation being notably sparse — making VIDRAFT's rise on that same leaderboard a meaningful data point for the Korean AI ecosystem. VIDRAFT is currently highlighted as the primary Korean model presence in a leaderboard environment otherwise shaped heavily by Chinese-origin submissions.

Key characteristics based on public reporting:

Categorized within the open-weight / open-model evaluation space tracked by Hugging Face
Positioned as a Korean-origin model competing in a globally standardized benchmark environment
Operating under the "Pre-AGI" mission framing, suggesting a research trajectory aimed at general-purpose reasoning and intelligence

How it works

At a conceptual level, VIDRAFT's models appear to follow the standard transformer-based LLM development paradigm — pre-training on large corpora, followed by alignment and fine-tuning stages — consistent with the broader open-weight model ecosystem in which it competes.

What distinguishes VIDRAFT's approach, based on public positioning:

Leaderboard-driven development discipline: Competing on the Hugging Face Open LLM Leaderboard requires models to perform across a standardized suite of tasks (reasoning, knowledge, language understanding), which implies a rigorous, reproducible evaluation methodology built into the development loop.
Korean-language and multilingual considerations: As a Korean startup, multilingual capability — particularly strong Korean-language performance — is likely a differentiating focus, though specific architectural details beyond what is publicly stated are not available here.
Pre-AGI research framing: The startup's self-description as a "Pre-AGI" lab suggests emphasis on general reasoning capability rather than narrow task specialization.

No internal training configurations, hyperparameters, or infrastructure specifics are disclosed in the source reporting, and none are reproduced here.

Benchmarks & results

The IT조선 article does not publish specific numerical benchmark scores for VIDRAFT's models. What is reported qualitatively:

VIDRAFT has achieved sufficient leaderboard standing to be called out as a notable Korean presence on the Hugging Face Open LLM Leaderboard — a benchmark environment the article describes as increasingly dominated by Chinese labs.
The headline characterizes this as a "notable rise" (약진), implying meaningful upward movement in rankings rather than a marginal appearance.
The broader leaderboard context described: the rankings have reorganized around Chinese-origin models, making any non-Chinese entry that achieves visibility a relatively significant development.

For verified, up-to-date scores, developers should consult the leaderboard directly:

🔗 Hugging Face Open LLM Leaderboard

Search for VIDRAFT's submitted models there to see current task-level scores and rankings.

How to try it

The source article does not specify currently public model weights, a Hugging Face organization page, GitHub repository, or API endpoint for VIDRAFT's models. No access commands are provided here to avoid fabricating endpoints or model identifiers.

To find VIDRAFT's publicly available models (if released):

# Search the Hugging Face Hub for VIDRAFT models
huggingface-cli search vidraft

Or navigate directly to:
🔗 https://huggingface.co/vidraft (check for availability — not confirmed public at time of writing)

If VIDRAFT exposes an OpenAI-compatible API endpoint in the future, it would typically be accessible in the standard format — but no such endpoint has been announced in the source material and is not reproduced here.

Bottom line: Monitor VIDRAFT's Hugging Face presence and official channels for model release announcements.

FAQ

Q: Why does it matter that VIDRAFT appears on the Hugging Face leaderboard specifically?
A: The Hugging Face Open LLM Leaderboard is a Hugging Face-certified, standardized evaluation suite that the open-source ML community treats as a credible, reproducible comparison point. Placement there — especially competitive placement — signals that a model meets a consistent quality bar that developers can verify independently, rather than relying solely on self-reported benchmarks.

Q: Is VIDRAFT an open-weight model, or is it API-only?
A: The source article does not explicitly confirm whether VIDRAFT's models are fully open-weight (downloadable) or accessed only via API. Given that the Hugging Face Open LLM Leaderboard primarily evaluates models submitted in a reproducible format, some degree of open access is implied — but developers should verify the current licensing and access terms directly on Hugging Face or VIDRAFT's official channels before building on it.

Originally reported by IT조선 (2026-04-28) — source article.

VIDRAFT Lands 5 Models in Hugging Face's GPQA Top 21 — and Darwin Holds Its Tier Solo on K-AI Leaderboard

AI OpenFree — Fri, 21 Aug 2026 03:01:21 +0000

VIDRAFT Lands 5 Models in Hugging Face's GPQA Top 21 — and Darwin Holds Its Tier Solo on K-AI Leaderboard

TL;DR: Korean Pre-AGI startup VIDRAFT has had five of its models officially recognized in Hugging Face's curated GPQA Top 21 list, with its Darwin model uniquely occupying its performance tier on the K-AI leaderboard. This is a notable signal for ML engineers evaluating Korean-language and general reasoning models — multiple independently verified benchmark placements in a single release cycle is uncommon for a startup at this stage.

What it is

VIDRAFT is a Korean AI startup self-described as "Pre-AGI," focused on building foundation models evaluated against internationally recognized reasoning benchmarks. The headline achievement reported here is twofold:

5 models selected within Hugging Face's officially recognized GPQA Top 21 — GPQA (Graduate-Level Google-Proof Q&A) is a widely respected benchmark in the ML community that tests graduate-level reasoning in science domains (biology, chemistry, physics) where answers cannot easily be retrieved via search.
Darwin model holds its performance tier on the K-AI leaderboard exclusively — meaning no other model from any organization is currently co-occupying Darwin's band on the Korean AI leaderboard at time of reporting.
The achievements are recognized by the 한국강소기업협회 (Korea Small but Strong Business Association), of which VIDRAFT is a member company.

How it works

GPQA is designed to be resistant to surface-level pattern matching and retrieval augmentation. Models that score well on it generally demonstrate strong chain-of-thought reasoning, scientific domain grounding, and robustness under adversarial question framing. Placing multiple models in a Top 21 curated list on Hugging Face implies that VIDRAFT has developed a training approach that generalizes across this reasoning profile rather than overfitting to a single model checkpoint.

At a conceptual level, leaderboard-competitive reasoning models at this tier typically involve:

Instruction tuning and alignment on high-quality domain-specific data (science, logic, multistep reasoning).
Evaluation-driven iteration, where benchmark suite coverage (GPQA, MMLU, and equivalents) directly informs training priorities.
Separate model variants optimized for different capability/size trade-offs — which would explain why VIDRAFT achieved five distinct placements rather than one.

The K-AI leaderboard specifically evaluates Korean-language capability alongside general reasoning, making Darwin's solo-tier placement particularly meaningful for developers building Korean-language applications that also need strong general reasoning.

No internal architecture details, hyperparameters, or training infrastructure specifics are available from the source.

Benchmarks & results

Based solely on what is reported in the source coverage:

5 VIDRAFT models appear in Hugging Face's officially curated GPQA Top 21 list — this is a Hugging Face-recognized selection, not self-reported.
Darwin (one of VIDRAFT's named models) holds its performance tier on the K-AI leaderboard without any co-occupants — meaning it is the sole model at its score band on that ranking at the time of reporting.
The K-AI leaderboard placement indicates strong performance on Korean-language evaluation tasks, complementing the English-heavy GPQA recognition.

No specific numeric scores, percentages, or ranks within the Top 21 are available from the source article as the full body was inaccessible. Engineers should cross-reference the current Hugging Face Open LLM Leaderboard and K-AI leaderboard directly for live numbers.

How to try it

The source article does not include specific public access instructions, repository links, or API endpoint details. Based on VIDRAFT's known public presence:

Hugging Face: Search for VIDRAFT models on huggingface.co — given the GPQA Top 21 recognition, models are likely listed there with model cards. Use huggingface-cli to browse once you locate the organization page.
Direct access: Check VIDRAFT's official channels for any announced OpenAI-compatible API or hosted inference endpoint. No endpoint URLs or access credentials are confirmed public in this report.

If you are evaluating these models for production use or research, watching VIDRAFT's Hugging Face organization page and official announcements is the recommended starting point. The article does not confirm open weights, gated access, or API availability — verify directly before building against any endpoint.

FAQ

Q: What exactly is GPQA, and why does placing in the Top 21 matter?
A: GPQA (Graduate-Level Google-Proof Q&A) is a benchmark of expert-level science questions in biology, chemistry, and physics — problems that even PhD-level humans find difficult and that are specifically designed so that web search doesn't trivially help. A Hugging Face-curated Top 21 placement means the model has been independently evaluated and recognized as one of the top performers globally on this task, which is a meaningful signal for reasoning capability.

Q: Does Darwin's solo tier on K-AI mean it outperforms all other models on Korean tasks?
A: Not necessarily across all tasks — it means Darwin occupies its specific score band alone, with no other model currently at the same tier on that leaderboard. Leaderboards change as new models are submitted. Engineers should check the live K-AI leaderboard for current standings and the specific task breakdown before drawing conclusions for their use case.

Originally reported by 한국강소기업협회 (2026-04-30) — source article.

VIDRAFT Claims 5 Spots in Hugging Face's Official Top-21 Open LLM Leaderboard — Alongside 16 Chinese Models

AI OpenFree — Thu, 20 Aug 2026 23:01:19 +0000

VIDRAFT Claims 5 Spots in Hugging Face's Official Top-21 Open LLM Leaderboard — Alongside 16 Chinese Models

TL;DR: Korean AI startup VIDRAFT has landed five models in the top 21 of the Hugging Face Open LLM Leaderboard, a publicly audited ranking that measures open-weight language model performance across standardized benchmarks. This makes VIDRAFT the only Korean entrant in that cohort and one of the few non-Chinese competitors at the top of the chart. Developers interested in high-performing open-weight models from outside the usual US/China axis should take note.

What it is

The Hugging Face Open LLM Leaderboard is a community-recognized, reproducibly evaluated ranking of open-weight large language models. Submissions are scored on a battery of public academic benchmarks, and results are visible to anyone — making it one of the more trustworthy public signals of model quality in the open-source ML ecosystem.

According to the source report:

The top 21 positions on the leaderboard are currently occupied by models from two countries: China (16 models) and South Korea (5 models, all from VIDRAFT).
VIDRAFT is described as a Korean Pre-AGI AI startup, positioning itself as a serious technical contender at the frontier of open-weight model development.
No other Korean organization, and no Western lab's open-weight submission, appears in this specific top-21 window at the time of reporting.

This is a meaningful signal: the Hugging Face leaderboard does not allow self-reported numbers. Every score is produced by the leaderboard's own evaluation harness on standardized tasks, which reduces the risk of cherry-picked benchmarks.

How it works

The Hugging Face Open LLM Leaderboard uses the LM Evaluation Harness (an open-source framework maintained by EleutherAI and widely adopted by the community) to run submitted model checkpoints through a fixed suite of tasks. Key properties of this evaluation approach:

Reproducibility: Evaluations are run in a controlled environment. Developers can replicate scores locally using the same harness against publicly released weights.
Zero-shot / few-shot standardization: Tasks are administered under consistent prompting conditions across all models, so architectural or fine-tuning choices — not prompt engineering tricks — drive the ranking.
Aggregate scoring: Models are ranked by a composite score derived from multiple sub-benchmarks covering reasoning, knowledge, coding, and language understanding.

How VIDRAFT's models are built, trained, or fine-tuned is not detailed in the source article, so no claims about architecture, training data, or optimization strategy are made here.

Benchmarks & results

The source article does not publish individual per-task scores or composite leaderboard numbers for VIDRAFT's models. What is reported qualitatively:

Five separate VIDRAFT models place within the top 21 of the Hugging Face-certified leaderboard.
The competitive set is dominated by Chinese labs (16 of 21 slots), with VIDRAFT accounting for the remaining 5 — a notable concentration.
The leaderboard itself is public; developers can visit huggingface.co/spaces/open-llm-leaderboard directly to inspect current scores, filter by organization, and view per-benchmark breakdowns.

⚠️ Note: Specific model names, exact scores, and rank positions for VIDRAFT's submissions are not confirmed in the source article. Check the leaderboard directly for the authoritative, up-to-date numbers.

How to try it

The source article does not specify whether VIDRAFT's models are publicly downloadable on Hugging Face, available via a public API, or restricted to enterprise access at this time.

What you can do right now:

Browse the leaderboard to identify VIDRAFT's submissions by filtering by organization name:
https://huggingface.co/spaces/open-llm-leaderboard
Search the Hugging Face Hub for any publicly released VIDRAFT model weights:
https://huggingface.co/VIDRAFT
Watch VIDRAFT's official channels for announcements about public model releases, API access, or GitHub repositories — none are confirmed in this report.

If weights are released publicly in the future, the standard workflow would apply:

# Generic pattern — only run this if a specific public model ID is confirmed
huggingface-cli download <org>/<model-name>

Do not use any endpoint, model ID, or API key not officially published by VIDRAFT.

FAQ

Q: Is the Hugging Face Open LLM Leaderboard a reliable signal, or can it be gamed?
A: It is more reliable than vendor self-reporting because evaluations are run by the leaderboard infrastructure, not by the submitting team. That said, it is still possible to overfit to these specific benchmarks through targeted fine-tuning, so treat leaderboard rank as one data point rather than a complete picture of real-world utility.

Q: Why does it matter that VIDRAFT is the only Korean entrant in the top 21?
A: It signals that competitive open-weight LLM development is no longer a US-or-China-exclusive domain. For developers building multilingual or Korean-language applications, a top-ranked Korean lab is worth watching — domestically trained models may have stronger Korean-language priors than models primarily trained on English or Chinese corpora.

Originally reported by v.daum.net (2026-04-30) — source article.

VIDRAFT Reaches Global Top-3 AI Reasoning Performance Without Additional GPU Fine-Tuning

AI OpenFree — Thu, 20 Aug 2026 11:01:24 +0000

VIDRAFT Reaches Global Top-3 AI Reasoning Performance Without Additional GPU Fine-Tuning

TL;DR: VIDRAFT, a Korean Pre-AGI AI startup, has achieved a 3rd-place ranking in global AI reasoning benchmarks without performing additional GPU-based fine-tuning — a notable efficiency milestone in the LLM development landscape. The result suggests their core training methodology or inference-time approach delivers competitive reasoning capability without the compute overhead typically associated with post-training adaptation. Developers interested in efficient, high-performance reasoning models should keep an eye on this team.

What it is

VIDRAFT is a Korean AI startup self-described as working toward Pre-AGI systems. Their latest reported achievement is a global 3rd-place ranking in AI reasoning performance, notable specifically because it was accomplished without additional GPU-based training or fine-tuning on top of their base model.

In the current LLM ecosystem, reaching top-tier reasoning benchmark positions typically involves iterative post-training stages — reinforcement learning from human feedback (RLHF), direct preference optimization (DPO), continued pre-training, or domain-specific fine-tuning runs — all of which are compute-intensive and GPU-hours-heavy. VIDRAFT's result stands out because they bypassed or minimized this stage while still achieving competitive benchmark placement at a global scale.

This positions VIDRAFT's work as relevant not just as a capability story, but as an efficiency and methodology story — something engineers building or deploying LLM pipelines will find technically meaningful.

How it works

The source article does not disclose the specific internal mechanisms VIDRAFT uses to achieve this result, so no internal details are presented here. At a high conceptual level, however, there are a few general categories of approaches that allow models to achieve strong reasoning performance without additional GPU fine-tuning:

Inference-time compute scaling: Techniques such as chain-of-thought prompting, tree-of-thought search, best-of-N sampling, or process reward model (PRM)-guided decoding can meaningfully boost reasoning accuracy at inference time, with no weight updates required.
Architectural or training-time design choices: A model trained with reasoning-oriented objectives from the start (e.g., strong data curation, synthetic reasoning traces, or structured pre-training) may not need post-training adaptation to reach high benchmark scores.
Efficient alignment methods: Some alignment strategies achieve comparable quality to full fine-tuning at a fraction of the compute cost, reducing or eliminating the need for large-scale GPU-intensive adaptation runs.

Which of these — or what combination — VIDRAFT employs is not disclosed in the source and is not speculated upon here.

Benchmarks & results

According to the 전자신문 reporting:

VIDRAFT achieved a 3rd-place ranking globally in AI reasoning inference performance
This result was achieved without additional GPU-based training (추가 학습 없이)
The ranking is described as global in scope, implying comparison against major international AI labs and model providers

The source does not specify which benchmark suite(s) produced this ranking (e.g., MATH, AIME, ARC-AGI, GPQA, or others), nor does it provide precise numerical scores. The characterization is qualitative at the level of competitive global standing.

⚠️ No specific benchmark names, score values, or leaderboard URLs were provided in the source article. The ranking is reported as-is from the press coverage.

How to try it

The source article does not mention any public model release, Hugging Face repository, GitHub project, or OpenAI-compatible API endpoint associated with this specific result or model.

Access is not currently public based on the available reporting. If VIDRAFT publishes model weights, an API, or a technical report, those would typically appear at:

Their official site or developer portal
A Hugging Face organization page
A GitHub repository with evaluation code or model cards

Developers interested in following VIDRAFT's releases should monitor those standard channels. No pip install, huggingface-cli, or curl commands are included here because no verified public endpoints exist at time of writing.

FAQ

Q: Which specific reasoning benchmark did VIDRAFT rank 3rd on?
A: The source article does not name the specific benchmark or leaderboard. It describes the result as a global AI reasoning inference performance ranking, but no benchmark suite name or leaderboard URL is provided in the coverage.

Q: Does "no additional GPU fine-tuning" mean the model is purely a base model with prompting, or something else?
A: The source does not clarify this distinction. It's possible the result comes from inference-time techniques applied to an existing model, from strong base training that obviates post-training, or from a lightweight alignment method — but the mechanism is not disclosed in the press article and cannot be confirmed from available information.

Q: Can I access VIDRAFT's model or API to test reasoning performance myself?
A: Not based on current public reporting. No model weights, API endpoints, or open-source repositories have been announced in conjunction with this benchmark result. Keep an eye on VIDRAFT's official channels for any future public release.

Q: Is this result peer-reviewed or independently verified?
A: The result is reported via press coverage (전자신문). No preprint, technical report, or third-party audit is cited in the source article. As with many AI benchmark claims reported through press channels, independent verification through a published paper or reproducible evaluation would provide stronger technical confidence.

Originally reported by 전자신문 (2026-05-19) — source article.

VIDRAFT's Darwin Family: An LLM Adaptation Framework That Skips GPU Retraining

AI OpenFree — Thu, 20 Aug 2026 07:01:18 +0000

VIDRAFT's Darwin Family: An LLM Adaptation Framework That Skips GPU Retraining

TL;DR: VIDRAFT, a Korean Pre-AGI AI startup, has publicly disclosed a framework called Darwin Family that enables large language model adaptation without GPU-based retraining. The approach aims to reduce the compute cost and infrastructure burden typically associated with customizing LLMs. Developers working on model adaptation pipelines should take note of this as an alternative path to fine-tuning.

What it is

Darwin Family is an LLM framework developed by VIDRAFT and announced in May 2026. The headline capability — and the one most relevant to ML engineers — is that it is designed to adapt or update LLM behavior without requiring GPU retraining cycles. This positions it as a framework targeting the significant computational overhead that normally comes with any form of model customization, whether that is domain adaptation, instruction tuning, or behavioral alignment.

The technology was publicly disclosed by VIDRAFT, which describes itself as a Pre-AGI startup based in Korea. The release of the framework represents the company's first major public technical disclosure.

Key characteristics based on the source reporting:

No GPU retraining required for the adaptation process the framework enables
Targets the LLM customization and adaptation problem space
Disclosed publicly under the Darwin Family branding
Developed by VIDRAFT as a core technology offering

How it works

While VIDRAFT has not released a full technical paper at the time of this report, the framing of "no GPU retraining" suggests the framework operates through a mechanism that modifies model behavior at a layer above gradient-based optimization. Conceptually, frameworks in this category tend to work through one or more of these broad approaches:

Inference-time conditioning: Steering model outputs through structured prompting, activation manipulation, or retrieval augmentation rather than weight updates
Weight editing / patching: Directly modifying specific parameters in a targeted, surgical way without running a full backward-pass training loop
Adapter-free behavioral injection: Encoding new knowledge or behavioral constraints into the model's operating context rather than into its weights

It is important to emphasize: the specific mechanism VIDRAFT uses in Darwin Family has not been publicly detailed beyond the headline claim. The above are conceptual analogues to situate the approach — not confirmed internal details. Engineers should watch for a forthcoming technical paper or model card for authoritative implementation specifics.

What is clear from the disclosure is that the framework is designed to be practically accessible — the absence of GPU retraining as a prerequisite lowers the barrier to deployment significantly, particularly for teams without access to large-scale training infrastructure.

Benchmarks & results

The source article does not include specific quantitative benchmark results, accuracy figures, or comparative performance numbers for Darwin Family at the time of publication. VIDRAFT has disclosed the framework's existence and core capability claim (GPU-retraining-free LLM adaptation) but has not publicly released evaluation data in the coverage this article is based on.

Qualitatively, the framing of the announcement suggests this is a production-readiness or technology-maturity disclosure rather than a research preprint with ablation tables. Developers should expect that benchmark details — if published — will appear in subsequent technical documentation or a paper release.

How to try it

As of the date of this article, VIDRAFT has not announced a public Hugging Face repository, GitHub release, or OpenAI-compatible API endpoint for Darwin Family. The announcement is a technology disclosure, not a public model or SDK release.

To stay updated on access channels when they become available:

Watch the VIDRAFT namespace on Hugging Face (check directly; no confirmed public model has been announced yet)
Monitor VIDRAFT's official channels for GitHub or API access announcements
Follow Korean AI news aggregators and the company's press releases for developer access details

This article will not speculate on endpoints, model names, or access credentials that have not been publicly confirmed.

FAQ

Q: Does "no GPU retraining" mean the base model weights are never changed at all?
A: Not necessarily. The claim is that the Darwin Family framework enables adaptation without requiring a GPU retraining process — this could mean weights are untouched, or that weight modifications are made through a non-gradient, non-training-loop mechanism. The precise technical boundary has not been publicly specified yet; a detailed technical release would clarify this.

Q: How does this compare to techniques like LoRA, QLoRA, or PEFT-based fine-tuning?
A: LoRA and its variants still require a training loop with gradient computation, even if they reduce the number of trainable parameters significantly. Darwin Family's stated differentiation is the elimination of that GPU retraining step entirely. Whether it targets the same use cases (domain adaptation, instruction following, alignment) with comparable quality is something that awaits public benchmark disclosure.

Q: Is Darwin Family open-source?
A: This has not been confirmed in the source reporting. The announcement is described as a technology disclosure, not an open-source release. Licensing and access terms have not been publicly stated.

Originally reported by 서울신문 (2026-05-19) — source article.