kakao·Mar 10, 2026·3 min readCurated summary

From Understanding Korean Culture to Screen Control: Everything About Kanana-V Feature Expansion

Kanana-V expands a vision-language model beyond single-image question answering into Korean cultural understanding, document analysis, multi-image reasoning, and GUI interaction. The post details how Kakao built and evaluated these capabilities through large-scale data curation, Korean benchmarks, and training optimizations. Its central conclusion is that language- and task-specific data quality, rather than scale alone, is essential for producing a practical multimodal model. ## Expanding VLM Capabilities - Real-world VLM applications require more than interpreting one image: - Understanding long PDF documents - Comparing multiple images - Interpreting and operating graphical user interfaces - Kanana-V targets these requirements through: - Korean-context understanding - Document and PDF comprehension - Multi-image and long-context processing - GUI grounding for Computer Use Agents (CUAs) - Compared with the similarly sized Qwen3-VL 4B, it achieved broadly comparable results and showed particular strength on Korean-language tasks. ## Curating Korean Interleaved Data - Interleaved datasets alternate images and text, as in blogs, enabling broad knowledge acquisition and stronger in-context learning. - The source collection reached hundreds of terabytes and contained substantial low-quality material, including advertisements, broken images, and duplicated posts. - Kakao used Hugging Face’s Datatrove framework to shard the data and run filtering pipelines in parallel. ## Eight-Stage Data-Cleaning Pipeline - **Image-based document filtering** - Removed broken, tiny, low-resolution, or extreme-aspect-ratio images. - Excluded documents left without valid images. - Used thresholds such as an aspect ratio above 3.0 or dimensions below 28 pixels. - **Language identification** - Applied FastText-based detection. - Retained documents with at least 90% probability of being Korean. - Preserved Korean technical content containing English quotations or code. - **Gopher repetition filtering** - Detected repeated lines, paragraphs, and abnormal 2-gram through 10-gram patterns. - Removed spam and automatically generated advertising content. - **Gopher quality filtering** - Adapted English-oriented rules for Korean. - Lowered the minimum average word length to one character because Korean tokenization often produces short tokens. - Added Korean particles and endings to stopword checks. - **C4 sentence-structure filtering** - Required at least four sentences. - Avoided punctuation-based filtering because Korean writing often omits sentence-final periods. - **FineWeb quality filtering** - Examined short-line ratios, bullet-list frequency, and lines ending in ellipses. - Removed product lists, menus, and similarly unsuitable formats. - **MinHash deduplication** - Used MinHash and locality-sensitive hashing to efficiently identify copied or highly similar documents without performing all pairwise comparisons. - **PII processing** - Masked Korean phone numbers, email addresses, and other personal information. - Cleaned empty text nodes created by image removal and merged adjacent text blocks. ## Impact of Filtering - Approximately 77% of the original data was removed, leaving 23% for training. - Ablation experiments showed that filtered data generally improved performance: - MMVet increased from 33.76 to 36.79. - LLaVA-Wild increased from 75.10 to 78.00. - Korean entity recognition increased from 50.05 to 53.66. - Korean food-menu understanding increased from 44.56 to 47.02. - Korean chart understanding was the exception, declining slightly from 58.33 to 57.43. - The team emphasizes: - Running inexpensive filters before costly ones - Saving intermediate outputs for inspection and reuse - Tuning thresholds for each language - Cleaning related text whenever images are removed from interleaved data The article’s practical recommendation is to treat multimodal model development as an end-to-end data and systems problem: carefully curate culturally relevant data, build language-specific evaluation sets, and optimize training pipelines for each target capability rather than relying solely on larger datasets or models.

Read original(opens in new tab)

MultimodalKanana VVision Language ModelComputer Use Agent+3

kakao·Mar 10, 2026·4 min readCurated summary

2026 Kakao Group New Crew Recruitment Coding Test Round 1 Problem Explanations

The post explains the first-round coding test for Kakao Group’s 2026 new-crew recruitment, covering seven problems of gradually increasing difficulty; the provided text details the first five. The solutions rely on string processing, simulation, graph traversal, and structural optimization. The main lesson is to exploit each problem’s constraints and identify the right representation before implementing. ## Problem 1: Preventing Spoilers in Important Words - Split the message into space-separated words and record each word’s character interval. - Classify words as spoiler-protected if their interval overlaps any spoiler range. - Store non-spoiler words in a set or hash map to detect duplicates. - Scan protected words from left to right: - Reject words appearing outside spoiler ranges. - Reject words duplicating an already revealed important word. - Count and record valid words. - Later test groups add overlapping spoiler ranges and duplicate words, requiring both types of deduplication. ## Problem 2: Yellow Traffic Lights - Each light repeats a cycle of green, red, and yellow durations. - The task is to find the first time when every light is yellow. - Since cycles repeat, simulation only needs to continue through the least common multiple of all cycle lengths. - Because each duration is at most 20, a bounded simulation is also feasible. - Possible implementations include: - Updating each light’s state every second. - Precomputing states up to the termination time. - Checking directly whether time `t` lies in each light’s yellow interval. - If no simultaneous yellow period occurs within a full combined cycle, the answer does not exist. ## Problem 3: Maximizing the Number of Leaf Nodes - A split of degree `k` consumes one unit of distribution budget and increases the leaf count by `k - 1`. - Since split degrees are limited to 2 and 3, every path product has the form `2^p × 3^q` and must remain within `split_limit`. - Two structural properties simplify the optimization: - Partial splitting can be rearranged so it occurs at only one depth within a consecutive block of equal split degrees. - Blocks of degree-2 splits should be placed above degree-3 blocks because they use less budget for the same eventual frontier size. - Therefore, an optimal tree consists of: - Consecutive layers of 2-way splits. - Followed by consecutive layers of 3-way splits. - At most one partially split layer. - Enumerate feasible pairs `(i, j)` satisfying `2^i × 3^j ≤ split_limit`. - Fully process each layer while budget allows; at the first insufficient layer, perform as many partial splits as possible and calculate the resulting leaf count. ## Problem 4: Virus Pipes - The tree’s edges use one of three pipe types: A, B, or C. - Opening a pipe type infects every currently reachable organism through connected pipes of that type. - Infection is permanent, and reopening the same type consecutively has no effect. - For each possible pipe-opening sequence: - Start a DFS or BFS from all infected organisms. - Traverse only edges of the selected type. - Mark newly reached organisms as infected. - Exhaustive search is practical because the number of pipe openings is at most 10, yielding at most `3^10 = 59,049` sequences. ## Problem 5: Organizing Kakao Apps - Apps are represented by square blocks on a grid. - Pushing one app by one cell can push blocking apps in the same direction. - Apps leaving one edge wrap around to the opposite side, potentially causing further collisions. - Process each command by: - Using the initially pushed app as a BFS seed. - Finding all apps that must move together. - Moving them one cell simultaneously. - Treating clipped apps that cross the boundary as new seeds. - Repeating until no new seeds remain. - Blocks may be larger than one cell, so collisions can propagate across multiple rows and columns. - With grid dimensions and block sizes bounded by 10, direct simulation is sufficiently efficient and terminates because the state space is finite. Overall, the recommended approach is to model each problem according to its mechanics: sets for duplicate word handling, periodicity for traffic lights, structural exchange arguments for tree optimization, exhaustive DFS/BFS for pipe sequences, and layered BFS simulation for grid movement.

Read original(opens in new tab)

AlgorithmsData StructuresGraph TraversalBreadth First Search+4

kakao·Mar 10, 2026·5 min readCurated summary

2026 Kakao Group New Crew Open Recruitment Coding Test Round 2 Problem Explanations

The post explains solutions to five problems from Kakao’s 2026 new-employee second-round coding test. The problems require a range of techniques: exhaustive search, dynamic programming, monotonic deques, prefix sums with arithmetic-sequence jumps, and backtracking. The central lesson is to exploit each problem’s structural constraints rather than simulate large data directly. ## Problem 1: Hint Stage - Enumerate every combination of stages where hint bundles are purchased using a bitmask from `0` to `2^n - 1`. - For each combination: - Track the number of hint tickets available at every stage with a `cnt` array. - Add the cost of solving each stage while using as many available hints as possible. - Add the purchase price when a bundle is selected. - Update future `cnt` values when tickets are purchased. - Guard against integer overflow when the number of tickets exceeds `n`. - The full solution uses exhaustive search; some subtasks can be solved more simply when bundles cost zero or contain only one ticket. ## Problem 2: Treasure Hunt - Use interval dynamic programming to minimize the cost required to guarantee finding the treasure, regardless of which column contains it. - Define: - `cost[L][R]`: minimum guaranteed cost when the treasure is somewhere between columns `L` and `R`. - `pick[L][R]`: the column to excavate first for that interval. - If column `i` is excavated: - The cost is `depth[i]` if the treasure is there. - If it is to the left, the additional cost is `cost[L][i-1]`. - If it is to the right, the additional cost is `cost[i+1][R]`. - Therefore, the required cost for choosing `i` is: `max(depth[i], depth[i] + cost[L][i-1], depth[i] + cost[i+1][R])` - Choose the `i` minimizing this value and store it in `pick[L][R]`. - With at most 200 columns, the `O(w^3)` dynamic programming solution is sufficient. - Reconstruct the excavation strategy by repeatedly narrowing the interval according to the result of `excavate(pick[L][R])`. - Simply choosing the middle column, even with heuristic weighting, is not guaranteed to be optimal. ## Problem 3: Hiding the Cactus - Convert the rainfall order into a grid: - Assign each wet cell the index of the raindrop that first reaches it. - Assign `INF` to cells that never receive rain. - For a `w × h` subgrid, its first rainfall time is the minimum value inside it. - The goal is to maximize this minimum, preferring the uppermost and then leftmost subgrid in case of ties. - Compute two-dimensional window minima efficiently: - Apply a monotonic deque horizontally to obtain minimum values for width-`w` windows in every row. - Apply the same technique vertically to those results using height-`h` windows. - Each deque processes elements in amortized `O(1)` time, producing: - Time complexity: `O(mn)` - Additional space: `O(mn)` - This is necessary because the grid may contain up to `5 × 10^5` cells. ## Problem 4: Squared-Count Array - `brr` is formed by repeating each `arr[i]` exactly `arr[i]` times. For example, `[2, 1, 5]` becomes `[2, 2, 1, 5, 5, 5, 5, 5]`. - Since `brr` can have total length up to `10^15`, it must not be constructed explicitly. - Build: - A prefix sum of `arr` to locate which repeated-value segment contains a given index in `brr`. - A prefix sum of `arr[i]^2` to calculate sums across complete segments. ### Calculating `K` - Divide the requested range `[l, r]` into: - The remaining part of the segment containing `l`. - Complete segments in the middle. - The beginning part of the segment containing `r`. - Each part can be calculated in constant time after preprocessing. - If both endpoints belong to the same segment, calculate the result as value × length. ### Calculating `C` - Count fixed-length windows whose sum equals `K`. - Moving a window one position changes its sum by: `new right value - old left value` - While both endpoints remain in the same repeated-value segments, this difference is constant, so window sums form an arithmetic progression. - Jump directly to the next segment boundary instead of moving one position at a time. - Within each arithmetic-progression interval, determine the number of windows summing to `K` mathematically. - This reduces the overall computation to `O(N)`. ## Problem 5: Train Tracks - Because the grid is at most 20 cells in each dimension, backtracking can enumerate valid track placements. - Simulate the train from `(1, 1)` to `(n, m)`. - When encountering an empty cell, try every track type that is compatible with: - The direction from which the train arrived. - The direction in which it will leave. - The search state must include both the current position and the previous travel direction. - Prune immediately when: - The train moves into an obstacle. - The current track does not connect in the required direction. - Upon reaching `(n, m)`, verify that: - Every placed track has been traversed. - Track type 3 has been traversed once horizontally and once vertically. - Valid configurations are counted only after all these conditions are satisfied. The recommended approach is to match the algorithm to the data structure of each problem: enumerate only when constraints permit it, use interval DP for guaranteed search strategies, monotonic deques for sliding minima, mathematical jumps for enormous implicit arrays, and carefully designed backtracking for small but highly constrained grids.

Read original(opens in new tab)

Dynamic ProgrammingSliding WindowDequeBacktracking+1

kakao·Feb 11, 2026·2 min readCurated summary

Introducing the new Kanana-o

Kanana-o is Kakao’s new Korean-focused omni-modal AI model, designed to understand and generate text, images, and audio naturally. Kakao is opening a closed beta for the Kanana-1.5-o-9.8b-2602 model to gather feedback from developers and partners before commercial release. The service emphasizes practical experimentation rather than large-scale traffic handling. ## Model Capabilities - Supports simultaneous processing of multiple modalities, including text, images, and audio. - Specializes in: - Deep understanding of Korean language, culture, and user intent. - Natural Korean speech with expressive intonation, pacing, and emotion. - Flexible applications such as podcast narration, multi-turn conversations, and multi-speaker text-to-speech. - Balances text-generation speed with audio-processing speed to produce more natural spoken responses. ## API Beta Service - **Service:** Kanana-o API Beta - **Model:** Kanana-1.5-o-9.8b-2602 - **Beta period:** February 27–May 27, 2026 - **Access:** Selected testers receive a fixed number of daily API uses during the beta. - The closed beta is intended for meaningful developer testing and feedback, not high-volume production workloads. ## Application and Selection - Applicants should visit [omni.kanana.ai](https://omni.kanana.ai/), sign in with a Kakao account, and submit information about: - Their organization or affiliation - Intended purpose - Expected technical scenarios - Selected applicants will receive invitations and API documentation through KakaoTalk notifications starting February 27. - Kakao is seeking developers, students, startups, and researchers with concrete implementation plans. - Specific proposals—such as building a visual shopping assistant for people with visual impairments—are favored over general interest in trying AI. Developers interested in exploring Korean-language, audio, and vision applications can apply for the beta with a clearly defined use case and prototype plan.

Read original(opens in new tab)

AIAPIKanana OText To Speech+1

kakao·Feb 8, 2026·4 min readCurated summary

In Search of Lost Reports: Kakao

KIMS, Kakao’s internal SMS platform, experienced rare cases where vendors sent delivery reports successfully, yet messages remained stuck in `SENT` instead of becoming `REPORTED`. The cause was a race condition: a fast vendor’s report arrived before the API server had committed the message record. The investigation showed that an unnecessarily long transaction—especially for paid messages with billing-event processing—delayed persistence and allowed valid reports to be dropped. ## KIMS Message Processing Flow - KIMS processes roughly one million SMS messages per day across multiple IDC environments and external vendors. - The normal flow is: - Route the request to a suitable vendor. - Call the vendor and record the message as `SENT`. - Deliver the message to the recipient. - Receive the vendor’s delivery report. - Update the message to `REPORTED`. - These stages run asynchronously across separate services, so their execution order is not guaranteed. ## Discovering the Missing Reports - Some messages remained in `SENT` even though Report Server logs confirmed that delivery reports had arrived. - The issue affected only about `0.02%` of messages, making it difficult to reproduce in tests or local environments. - Two patterns emerged: - Missing reports were concentrated among messages sent through one particular vendor. - Paid messages were affected more often than free messages. ## The Race Condition - The problematic vendor returned reports unusually quickly: - Other vendors typically took more than one second. - This vendor averaged around 20 ms. - Missing-report cases averaged only about 8 ms. - The API server performed additional processing before committing the message record. - For paid messages, billing-event publication was included in the same `@Transactional` scope, making the transaction longer. - Consequently, the sequence could become: 1. API Server calls the vendor. 2. API Server performs billing-related processing. 3. The vendor delivers the message and immediately sends a report. 4. Report Server receives the report before the message row exists in the database. 5. Report Server treats the report as invalid and drops it. 6. API Server finally commits the message as `SENT`. - The report was not lost at the network or vendor level; it was discarded because the system’s write path had not completed. ## Reducing Transaction Scope - The first fix was to remove nonessential work from the main transaction. - Billing-event publication was moved to asynchronous processing using `@Async` and `@TransactionalEventListener`. - The transaction was reduced to the essential state change and database commit. - This advanced the average commit point by approximately 10 ms and significantly reduced report omissions. - It also avoided a dual-write anti-pattern in which an external Kafka event was published inside a database transaction that could later roll back. ## Reconsidering the Need for a Transaction The incident prompted a broader review of whether the transaction was needed at all. - **Atomicity:** The transaction contained only one database write, with no multi-table or cross-record operation requiring all-or-nothing rollback. - **Read isolation:** Metadata such as vendor quality metrics was updated only every few minutes, and using a slightly stale value was acceptable. The independently read tables did not require a single consistent snapshot. - **Write isolation:** JPA’s dirty checking kept the status change in the persistence context until transaction completion, delaying the actual database write. This delay was precisely what allowed the report to arrive first. The article therefore presents the transaction itself—not the vendor or report receiver—as a source of unnecessary latency and an architectural anti-pattern in this workflow. ## Practical Recommendation Use transactions only when their guarantees are required. Keep critical persistence paths short, move external events and nonessential processing after commit, and critically evaluate whether delayed commit semantics could allow asynchronous consumers to observe a missing record.

Read original(opens in new tab)

Apache KafkaDistributed SystemsMysqlRace Condition+4

kakao·Jan 29, 2026·2 min readCurated summary

Recruiting new Kakao AI Ambassadors ‘

Kakao is recruiting 100 participants for its expanded KANANA 429 AI ambassador program. The five-month program introduces separate tracks for AI experts, creators, and university students, offering opportunities to test Kakao AI services, create content, and provide feedback. Applications close at noon on February 19, 2026. ## Program Purpose and Name - KANANA 429 promotes Kakao’s AI technologies and gathers user feedback. - “429” references the HTTP status code “Too Many Requests,” representing people with abundant enthusiasm and ideas about AI. - The program builds on Kakao’s first ambassador cohort, which included 20 participants. ## Results from the Previous Cohort - Participants communicated through KakaoTalk Open Chat. - They attended monthly offline meetups, informal group activities, and networking sessions with Kakao employees. - They previewed new Kakao AI services and exchanged feedback. - The cohort produced roughly 100 reviews and other pieces of content about Kakao’s AI services, models, and technologies. - Kakao selected and awarded five outstanding ambassadors. ## New Tracks and Benefits - **AI experts:** Test Kakao’s latest AI services and models and write in-depth reviews. - **Creators:** Produce content demonstrating practical ways to use Kakao AI. - **University students:** Promote the program on and off campus and collect user opinions. - The activity period has increased from three to five months. - Selected ambassadors receive AI service usage opportunities worth approximately 1 million won, along with additional benefits and special merchandise. ## Application and Schedule - Applicants must publish content related to Kakao AI and submit its URL through the recruitment page. - Applications are accepted until noon on February 19, 2026. - Every applicant receives a one-month free Kakao Emoticon Plus subscription. - Selected participants will be notified individually through Kakao’s official KakaoTalk channel on March 4. - The opening ceremony is scheduled for March 13 at Kakao AI Campus. Kakao is seeking applicants who are genuinely interested in AI and willing to communicate openly while helping shape and spread its AI services.

Read original(opens in new tab)

AIAi ModelsKananaAi Services+2

kakao·Jan 15, 2026Original article

Kanana-2 Development Story ( (opens in new tab)

Kakao has introduced Kanana-2, a series of language models utilizing a Mixture of Experts (MoE) architecture to achieve high intelligence while maintaining low inference costs. To support the stable pre-training of their largest 155B parameter model, the team implemented advanced technical stacks including the Muon optimizer and MuonClip to prevent training instabilities. These developments reflect a strategic focus on balancing large-scale performance with "high-efficiency, low-cost" engineering. ### MoE Architecture and Scaling Strategy * Kanana-2 models, such as the 32B version, activate only 3B parameters during inference to maximize computational efficiency without sacrificing the intelligence of a larger model. * The team is currently training a massive 155B parameter version (Kanana-2-155b-a17b) using FP8 training infrastructure, MuonClip, and Hyperparameter Transfer to ensure stable convergence. * Custom-developed MoE kernels were integrated to reduce memory usage and increase training speed, resulting in a highly stable Loss Curve even during constant learning rate phases. ### A Controlled Testbed for Mid- and Post-Training * The Kanana-2-30b-a3b-base-2601 model was intentionally released without synthetic reasoning data to serve as a "clean" base for research. * This model allows researchers to investigate phenomena like "Reasoning Trace Distribution Mismatch" and "Spurious Rewards" by providing a baseline unaffected by post-training interventions. * By offering a high-quality Korean base model, Kakao aims to support the local AI community in conducting more rigorous experiments on mathematical and logical reasoning. ### Optimization with Muon and Polar Express * Kakao shifted from the industry-standard AdamW optimizer to Muon, which updates parameters by orthogonalizing gradients rather than performing element-wise updates. * To achieve more accurate orthogonalization, they implemented the Polar Express iterative algorithm instead of the standard Newton-Schulz method, aiming to reduce noise in weight updates during the latter stages of large-scale training. * The optimization process also involved detailed adjustments to RMSNorm parameterization and learning rate (LR) management to ensure the model scales effectively. ### Training Stability via MuonClip * To address potential "logit explosion" in large-scale models, the team utilized MuonClip, a technique that clips attention logits to maintain stability. * Because standard Flash Attention stores Max Logit values only on-chip, the team modified the Flash Attention kernels to extract and return these values for monitoring and clipping purposes. * Stress tests conducted with high learning rates proved that MuonClip prevents training divergence and maintains performance levels even when the model is pushed to its limits. The development of Kanana-2 demonstrates that scaling to hundreds of billions of parameters requires more than just data; it necessitates deep architectural optimizations and custom kernel engineering. For organizations looking to train large-scale MoE models, adopting sophisticated orthogonalization optimizers and logit clipping mechanisms is highly recommended to ensure predictable and stable model convergence.

Large Language ModelsAi InfrastructureMixture Of ExpertsPre Training+3

kakao·Jan 15, 2026Original article

Kanana-2 Development Log ( (opens in new tab)

Kakao’s development of the Kanana-2 model family represents a strategic shift toward Agentic AI, prioritizing complex reasoning and execution capabilities over simple conversational fluency. By implementing a sophisticated post-training pipeline—including a specialized Mid-training stage and refined reinforcement learning—the team successfully enhanced the model's instruction-following and tool-calling performance. This methodology ensures that the 30B parameter models excel in logical tasks and real-world agentic environments while maintaining high linguistic stability in both English and Korean. ## Mid-training and Catastrophic Forgetting Prevention * A 250B token Mid-training stage was introduced between Pre-training and Post-training to bridge the gap in reasoning, coding, and tool-calling capabilities. * The dataset comprised 200B tokens of high-quality reasoning data (Chain-of-Thought math and code) and 50B tokens of "replay" data from the original pre-training set. * This replay strategy specifically targeted "Catastrophic Forgetting," preventing the model from losing its Korean linguistic nuances and performance on benchmarks like KoMT-bench while it gained English-heavy reasoning skills. * Experimental results indicated that Mid-training serves as a foundational "force multiplier," leading to faster convergence and higher performance ceilings during subsequent Supervised Fine-Tuning (SFT) and Reinforcement Learning (RL) stages. ## Enhanced Instruction Following and Tool Calling * To optimize for Agentic AI, the developers focused on Instruction Following (IFEval) by synthesizing high-quality, long-form responses that strictly adhere to complex constraints. * Tool-calling capabilities were improved using "Rejection Sampling" (Iterative SFT), where model-generated trajectories are validated in a real execution environment; only successful outcomes are retained for training. * The training data was categorized into distinct buckets—such as Chat, Math, Code, and Tool Calling—allowing for a more balanced recipe compared to previous Kanana versions. * This approach specifically addressed multi-turn and multi-tool scenarios, ensuring the model can handle the recursive logic required for autonomous agents. ## Parallel Reinforcement Learning and Calibration Tuning * A "Parallel RL" framework was adopted to optimize different capabilities simultaneously: the "Chat" track focused on helpfulness and safety, while the "Logic" track focused on accuracy in math and programming. * The pipeline moved beyond standard SFT to include Reinforcement Learning from Human Feedback (RLHF), utilizing DPO and PPO-style methods to align the model with human preferences. * A final "Calibration Tuning" step was implemented to ensure the model’s internal confidence levels match its actual accuracy, effectively reducing hallucinations and improving reliability in technical tasks. * Comparative benchmarks show that the Kanana-2 Instruct and Thinking models significantly outperform earlier versions and rival larger open-source models in reasoning and coding benchmarks like HumanEval and GSM8K. The Kanana-2 development cycle demonstrates that achieving "Agentic" performance requires more than just scaling data; it requires a structured transition from general language understanding to execution-verified reasoning. For organizations building AI agents, the Kanana-2 post-training recipe suggests that integrating environment-validated feedback and balancing reasoning data with foundational language "replays" is critical for creating reliable, multi-functional models.

AILarge Language ModelsAI AgentsReinforcement Learning+5

kakao·Jan 4, 2026Original article

Kakao’s “ (opens in new tab)

Kakao's Kanana-v-4b-hybrid is a multimodal language model designed to transcend simple image-to-text conversion by integrating logical reasoning and self-verification directly into its response process. By employing a hybrid architecture that handles both intuitive dialogue and complex visual reasoning within a single model, it achieves high accuracy and reliability for sophisticated tasks. This approach allows the model to maintain consistency in user experience while excelling in Korean-specific contexts, as evidenced by its record-breaking 92.8 score on the KoNET evaluation. ### Integrated Hybrid Architecture * Consolidates intuitive tasks (like OCR and summarization) and logical tasks (complex reasoning) into a single model to reduce system complexity and maintenance costs. * Eliminates the need for external routing between specialized models, ensuring a consistent tone, response format, and safety policy throughout a single conversation session. * Utilizes a refined training recipe that balances data ratios and visual reasoning training to ensure that improvements in multimodal understanding benefit all types of user queries. ### Visual Reasoning and Self-Reflection * Follows a natural logic flow: synthesizing information from images and text, applying conditions, verifying candidates, and finally concluding the response. * Features a "Reflection" mechanism where the model actively monitors its own thought process to catch "small but fatal" errors, such as calculation mistakes or missed constraints. * Excels in high-stakes visual tasks like receipt auditing, table filtering, and mathematical problem-solving by double-checking intermediate results against original image data. ### Native Korean Logical Processing * Prioritizes "thinking in Korean" to accurately preserve the nuances of complex constraints, such as "except for X" or "only in cases of Y," which are often lost during internal translation. * Develops a native Korean Rationale process to prevent logical drift, ensuring that the internal reasoning steps remain perfectly aligned with the linguistic structure of the user's query. * Addresses the difficulty of processing information scattered throughout Korean-language documents or exam papers by synthesizing data without language-conversion overhead. Kanana-v-4b-hybrid marks a shift toward "verifiable AI" that provides evidence-based answers rather than just plausible text. For applications in education, finance, or complex document processing, this model offers a blueprint for building trust through transparent reasoning and self-correction.

Multimodal AIKananaChain Of ThoughtOcr+3

kakao·Dec 21, 2025Original article

Development of an Ultra-lightweight Classic (opens in new tab)

Kakao developed a specialized, lightweight morphological analyzer to meet the strict resource constraints of mobile environments where modern deep-learning models are often too heavy. By opting for a classical Viterbi-based approach implemented in C++20, the team successfully reduced the library's binary size to approximately 200KB while ensuring high performance. This development highlights how traditional algorithmic optimization and careful language selection remain vital for mobile software efficiency. ## The Choice of C++ over Rust - While Rust was considered for its safety, it was ultimately rejected because its default binary size (even with optimization) reached several megabytes, which was too large for the specific project requirements. - C++ was chosen because mobile platforms like iOS and Android already include standard libraries (libc++ or libstdc++), allowing the final analyzer binary to be stripped down to core logic. - The project utilized C++20 features such as Concepts and `std::span` to replace older patterns like SFINAE and `gsl::span`, resulting in more readable and maintainable code without sacrificing performance. ## Trie Compression using LOUDS - To minimize the dictionary size, the team implemented a LOUDS (Level-Order Unary Degree Sequence) structure, which represents a Trie using a bit sequence instead of pointers. - This approach provides a compression rate near the information-theoretic lower bound, allowing approximately 760,000 nodes to be stored in just 9.4MB. - Further optimization was achieved through a custom encoding scheme that represents Hangul in 2 bytes and English in 1 byte, significantly reducing the dictionary's memory footprint compared to standard UTF-8. ## Optimizing the Select Bit Operation - Initial performance profiling showed that the `select0` operation (finding the N-th zero in a bit sequence) consumed 90% of the dictionary search time due to linear search overhead. - The solution involved dividing the bit sequence into 64-bit chunks and storing the cumulative count of zeros at each chunk boundary in a separate array. - By using binary search to find the correct chunk and applying parallel bit-counting techniques for intra-chunk searching, the dictionary search time was reduced from 165ms to 10ms. - These optimizations led to a total analysis time improvement from 182ms to 28ms, making the tool highly responsive for real-time mobile use. For mobile developers facing strict hardware limitations, this project proves that combining classical data structures like LOUDS with modern low-level language features can yield performance and size benefits that deep learning alternatives currently cannot match.

AINatural Language ProcessingMobile DevelopmentOptimization+5

kakao·Dec 18, 2025Original article

Smarter and More (opens in new tab)

Kakao has released Kanana-2, a high-performance open-source language model specifically engineered to power Agentic AI by enhancing tool-calling and instruction-following capabilities. Surpassing its predecessors and rivaling global frontier models like Qwen3, Kanana-2 offers a versatile suite of variants designed for practical, high-efficiency application in complex service environments. ### Optimized Model Lineup: Base, Instruct, and Thinking * **Kanana-2-30b-a3b-base:** Provided as a foundational model with pre-training weights, allowing researchers to fine-tune the model using their own datasets. * **Kanana-2-30b-a3b-instruct:** A version optimized through post-training to maximize the model's ability to follow complex user instructions accurately. * **Kanana-2-30b-a3b-thinking:** Kakao’s first reasoning-specialized model, designed for tasks requiring high-level logical thinking, such as mathematics and coding. ### Strengthening Agentic AI Capabilities * **Tool Calling:** Multi-turn tool-calling performance has improved more than threefold compared to Kanana-1.5, significantly enhancing its utility with the Model Context Protocol (MCP). * **Instruction Following:** The model's ability to understand and execute multi-step, complex user requirements has been refined to ensure reliable task completion. * **Reasoning-Tool Integration:** Unlike many reasoning models that lose instruction-following quality during deep thought, the "Thinking" variant maintains high performance in both logical deduction and tool use. ### High-Efficiency Architecture for Scale * **MLA (Multi-head Latent Attention):** Compresses memory usage to handle long contexts more efficiently, reducing the resources needed for extensive data processing. * **MoE (Mixture of Experts):** Activates only the necessary parameters during inference, maintaining high performance while drastically reducing computational costs and response times. * **Improved Tokenization:** A newly trained tokenizer has improved Korean language token efficiency by 30%, enabling faster throughput and lower latency in high-traffic environments like KakaoTalk. ### Expanded Multilingual Support * **Broad Linguistic Reach:** The model has expanded its support from just Korean and English to include six languages: Korean, English, Japanese, Chinese, Thai, and Vietnamese. By open-sourcing Kanana-2, Kakao provides a robust foundation for developers seeking to build responsive, tool-integrated AI services. Its focus on practical efficiency and advanced reasoning makes it an ideal choice for implementing agentic workflows in real-world applications where speed and accuracy are critical.

Large Language ModelsAI AgentsOpen SourceHugging Face+4

kakao·Dec 16, 2025Original article

12 Reasons to Upgrade to MongoDB (opens in new tab)

MongoDB 8.0 marks a significant shift in the database's evolution, moving away from simple feature expansion to prioritize architectural stability and substantial performance gains. By addressing historical criticisms regarding write latency and query overhead, this release establishes a robust foundation for enterprise-scale applications requiring high throughput and long-term reliability. ### Extended Support and Release Strategy * MongoDB 8.0 is designated for five years of support (until October 2029), offering a stable "LTS-like" window that reduces the resource burden of frequent major upgrades. * The "Rapid Release" policy, previously exclusive to MongoDB Atlas, now extends to on-premise environments, allowing self-managed users to access minor release features and improvements more quickly. * This policy change provides DBAs with greater strategic flexibility to choose between prioritizing stability or adopting new features. ### Optimized "Majority" Write Concern * The criteria for "majority" write acknowledgment has shifted from `lastApplied` (when data is written to the data file) to `lastWritten` (when the entry is recorded in the `oplog.rs` collection). * This change bypasses the wait time for secondary nodes to physically apply changes to their storage engines, resulting in a 30–47% improvement in write throughput. * While this improves speed, applications that read from secondaries immediately after a write may need to implement Causally Consistent Sessions to ensure they see the most recent data. ### Efficient Bulk Operations * A new database-level `bulkWrite` command allows for operations across multiple collections within a single request, reducing network round-trip costs. * The system now groups multiple document inserts (up to a default of 500) into a single oplog entry instead of creating individual entries for every document. * This grouping aligns the oplog process with the WiredTiger storage engine’s internal batching, significantly reducing replication lag and improving overall write efficiency. ### High-Speed Indexing with Express Plan * MongoDB 8.0 introduces the "Express Plan" to optimize high-frequency, simple queries by bypassing the traditional multi-stage query optimizer. * Queries are eligible for this fast-track execution if they are point queries on the `_id` field or equality searches on fields with unique indexes (or queries using `limit: 1`). * By skipping the overhead of query parsing, normalization, and plan stage construction, the Express Plan maximizes CPU efficiency for the most common database interaction patterns. For organizations managing large-scale production environments, MongoDB 8.0 is a highly recommended upgrade. The combination of a five-year support lifecycle and fundamental improvements to replication and query execution makes it the most performant and operationally sound version of the database to date.

Query OptimizationMongodbDatabase PerformanceMongodb 8 0+4

kakao·Dec 11, 2025Original article

Korean and Images at Once (opens in new tab)

Kakao has developed Kanana-v-embedding, a specialized multimodal embedding model designed to bridge the gap between Korean text and visual data within a unified semantic space. By leveraging a Vision-Language Model (VLM) framework, the model enables seamless search and recommendation across various combinations of text and images, offering a significant performance boost over existing English-centric models like CLIP. This development provides a robust technical foundation for enhancing Kakao’s services, including RAG-based systems and localized content discovery. ### Unified Multimodal Meaning Space * The model maps text and images into a single vector space where semantic similarity is measured via cosine similarity. * Unlike traditional CLIP models that use independent encoders, this architecture treats text and images as a single sequence, allowing for "text + image" combined queries. * It supports four primary interaction modes: Text-to-Text, Text-to-Image, Image-to-Image, and (Text+Image)-to-(Text+Image). ### VLM-Based Architecture and Instruction Tuning * The system utilizes a VLM consisting of an LLM and an image encoder, extracting embeddings from the final hidden state of the [EOS] token. * It employs instruction-based query embedding, where specific prompts (e.g., "Find an image matching this caption") guide the model to generate embeddings tailored to the specific task, such as retrieval or classification. * The model is optimized for the Korean language and cultural context, addressing the limitations of previous models that struggled with non-English data. ### Advanced Training for Scalability and Precision * **Gradient Caching:** To overcome GPU memory limitations, this technique allows the model to train with effectively large batch sizes, which is critical for the InfoNCE loss used in contrastive learning. * **Matryoshka Representation Learning (MRL):** The model supports flexible embedding sizes ranging from 64 to 2,048 dimensions. This allows services to choose between low-latency (smaller dimensions) or high-precision (larger dimensions) without retraining. * **Hard Negative Mining:** The training process incorporates "hard negatives"—items that are similar but incorrect—to sharpen the model’s ability to distinguish between subtle differences in data. ### Performance Benchmarks and Efficiency * Kanana-v-embedding significantly outperforms CLIP and VLM2Vec on the KoEmbed benchmark, particularly in Korean Text-to-Image and Image-to-Text retrieval tasks. * In the M-BEIR (Multimodal Benchmark for Retrieval), the model demonstrated superior performance in multimodal document retrieval and image-to-text tasks compared to established open-source models. * Evaluation of MRL showed that the model retains high accuracy even when dimensions are reduced to 256 or 512, providing a 4x to 8x improvement in storage and search efficiency with minimal loss in quality. For organizations looking to implement multimodal RAG or advanced recommendation systems in Korean-language environments, Kanana-v-embedding offers a highly adaptable solution. Its ability to balance computational cost and retrieval quality through Matryoshka learning makes it particularly suitable for large-scale production environments where latency is a primary concern.

Large Language ModelsRAGContrastive LearningMultimodal Embedding+4

kakao·Dec 11, 2025Original article

The Evolution of Kanana-o Toward (opens in new tab)

Kakao has significantly advanced its integrated multimodal model, Kanana-o, by enhancing its ability to process complex instructions across text, image, and audio inputs while enriching its emotional vocal expression. By developing specialized datasets and sophisticated training techniques for prosody, the team has bridged the performance gap between text and audio modalities. The result is a more natural, human-like AI capable of nuanced interaction and high-performance instruction following, particularly within the Korean linguistic context. ## Advancing Multimodal Instruction Following * Addressed the "modality gap" where multimodal models often show decreased reasoning and reasoning performance when processing audio inputs compared to text. * Constructed a structured, high-quality dataset featuring complex, multi-step instructions such as summarizing a context and then translating it into a specific language or style. * Leveraged the Speech-KoMT-Bench to evaluate performance, showing that Kanana-o significantly outperforms global competitors of similar scale in Korean-specific tasks. * Focused on "Domain-generalization" to ensure the model's core intelligence remains stable regardless of whether the input is text, audio, or a combination of both. ## Image-Audio-Text Modality Alignment * Developed integrated datasets to ensure that reasoning capabilities learned in text-image or text-audio contexts generalize to complex image-audio scenarios. * Trained the model to handle tasks where users ask questions about visual information via voice, requiring the simultaneous alignment of three different data types. * Prioritized the maintenance of "World Knowledge" during multimodal training so that the addition of new modalities does not degrade the model’s factual accuracy. ## Enhancing Vocal Expressiveness and Prosody * Focused on "prosody"—the rhythm, pitch, and stress of speech—to move beyond robotic, flat text-to-speech (TTS) outputs. * Implemented a system of descriptive tokens and emotion tags (e.g., "warm voice," "excited tone") during training to give the model fine-grained control over its vocal persona. * Incorporated natural human speech elements, such as realistic breathing patterns and contextual variations in speech speed, to make interactions feel more intuitive and less synthetic. * Refined the model's ability to interpret the user's emotional state from their voice and respond with a matching emotional intensity. The evolution of Kanana-o highlights a shift from simply maximizing generic benchmarks to optimizing real-world user experiences through multimodal alignment and emotional intelligence. The success of this model underscores the necessity of high-quality, structured instruction data and fine-grained control over output styles to create truly conversational AI that feels natural to the user.

AIKananaMultimodalSpeech Synthesis+4

kakao·Dec 3, 2025Original article

What the AI TOP 1 (opens in new tab)

The Kakao AI Native Strategy team successfully developed a complex competition system for the "AI TOP 100" event in just two weeks by replacing traditional waterfall methodologies with an AI-centric approach. By utilizing tools like Cursor and Claude Code, the team shifted the developer’s role from manual coding to high-level orchestration and validation. This experiment demonstrates that AI does not replace developers but rather redefines the "standard" of productivity, moving the focus from execution speed to strategic decision-making. ### Rapid Prototyping as the New Specification * The team eliminated traditional, lengthy planning documents and functional specifications. * Every team member was tasked with creating a working prototype using AI based on their own interpretation of the project goals. * One developer produced six different versions of the system independently, allowing the team to "see" ideas rather than read about them. * Final requirements were established by reviewing and merging the best features of these functional prototypes, significantly reducing communication overhead. ### AI-Native Development and 99% Delegation * The majority of the codebase (over 99%) was generated by AI tools like Claude Code and Cursor, with developers focusing on intent and review. * One developer recorded an extreme usage of 200 million tokens in a single day to accelerate system completion. * The high productivity of AI allowed a single frontend developer to manage the entire UI for both the preliminary and main rounds, a task that typically requires a much larger team. * The development flow moved away from linear "think-code-test" patterns to a "dialogue-based" implementation where ideas were instantly turned into code. ### PoC-Driven Development (PDD) * The team adopted a "Proof of Concept (PoC) Driven Development" model to handle high uncertainty and tight deadlines. * Abstract concepts were immediately fed into AI to generate functional PoC code and architectural drafts. * The human role shifted from "writing from scratch" to "judging and selecting" the most viable outputs generated by the AI. * This approach allowed the team to bypass resource limitations by prioritizing speed and functional verification over perfectionist documentation. ### Human Governance and the Role of Experience * Internal conflicts occasionally arose when different AI models suggested equally "logical" but conflicting architectural solutions. * Senior developers played a critical role in breaking these deadlocks by applying real-world experience regarding long-term maintainability and system constraints. * While AI provided the "engine" for speed, human intuition remained the "steering wheel" to ensure the system met specific organizational standards. * The project highlighted that as AI handles more of the implementation, a developer’s ability to judge code quality and architectural fit becomes their most valuable asset. This project serves as a blueprint for the future of software engineering, where AI is treated as a peer programmer rather than a simple tool. To stay competitive, development teams should move away from rigid waterfall processes and embrace a PoC-centric workflow that leverages AI to collapse the distance between ideation and deployment.

AIGeminiClaudeCursor+5