At WAIC 2026, Singapore-based AI infrastructure company Acrab unveiled the Agent Box and GΞLIX 1 chip, designed to provide the computational foundation for edge-side agentic AI. Unlike traditional AI chips, the GΞLIX 1 emphasizes heterogeneous collaboration between CPU and NPU, a unified memory architecture, and prefill optimization, delivering 700 TOPS of compute power and 273 GB/s memory bandwidth. CEO Ken Phua believes AI has entered the era of heterogeneous computing, with the CPU once again returning to the center stage; Acrab has raised over $350 million in total funding. Edge AI is shifting from “running a single model” to “long-term operation of an intelligent system,” where true competition lies in the integrated capability of chips, software stacks, and agent ecosystems.Author and source: AI New Era
What kind of computing infrastructure should agentic AI run on?
Several days have passed, and one of the most crowded concepts at WAIC 2026—the Agent Computer—is beginning to shift from a novel exhibit attraction to a genuine engineering challenge.
Running a large model on a local device is no longer the hardest part. The greater challenge lies in whether the chip can maintain stability under constraints of power consumption, latency, and cost, while the agent continuously reads files, retains memory, invokes tools, and runs in the background over extended periods.
This will transform how edge chip performance is evaluated. TOPS, model parameters, and tokens per second still matter, but if memory bandwidth is insufficient, CPU and NPU coordination is poor, or the software stack cannot maintain task state, even the most impressive peak performance may only suffice for a single demo.
We noticed that this week, Singapore-based company Acrab held an online launch event and released the Agent Box, which may serve as a sample for analysis.
At this launch event, the AI infrastructure company showcased Prefill, unified memory, CPU-NPU heterogeneous collaboration, and agent orchestration all at once.
These keywords point to the same conclusion: edge AI is evolving from "running a model" to "long-term operation of an intelligent system."
The challenge for chips is no longer just whether they have sufficient computing power, but how data flows, how tasks are scheduled, and how software and hardware can continuously collaborate.
So, as the buzz around WAIC, new product launches, and industry trends settles down, the more meaningful questions become clearer: When agents shift from single interactions to continuous operation, what exactly needs to be reimagined in edge-side chips?
From a single inference to continuous operation
The agent changed the edge-side load.
Chatbots typically complete a single round of Q&A. After receiving a task, an agent may first search for information, read files, then invoke code, browsers, calendars, or office software; after completing part of the task, it checks the results, preserves the task state, and waits for the next trigger. A single task often involves multiple model invocations and repeated switching between different models, tools, and applications.
Acrab demonstrated a relatively complete task workflow during the launch: a user requests to create a space-themed gift for their child, and the system responds by generating ideas, assisting with option selection, invoking relevant tools, and tracking production progress; when new conditions arise in the environment, it can connect to other smart devices to handle them.
The significance of this demo lies not in how clever a single response is, but in whether a piece of natural language can be transformed into a sequence of continuous actions. For computational systems, an agent is no longer just “calling a model once,” but rather continuously switching between models, data, software, and devices.
This workflow first enhances the division of labor between the endpoint and the cloud.
The cost of a single inference may be low, but as calls become frequent and sustained, tokens shift from being a technical metric to a real bill; a single network delay has limited impact on a chat, but when multiplied across multi-step tasks, delays accumulate layer by layer; for an agent to grasp a more complete personal context, data must repeatedly travel to and from the cloud, expanding the attack surface.
Therefore, edge and cloud are not mutually exclusive. A more practical architecture is to keep high-frequency, privacy-sensitive tasks requiring fast response and persistent state on-device whenever possible, and offload complex reasoning beyond the device’s capabilities to the cloud.
The real change is that edge devices are no longer just handling a single model inference, but rather a continuous intelligent system that cannot be easily interrupted.
It must run large models while handling long contexts, multiple tasks, and tool calls; performance must be sufficiently strong, without letting power consumption and costs spiral out of control, and the runtime, toolchain, and agent ecosystem must all advance in tandem.
Edge-side large models address whether the model can fit on the device; agentic AI addresses whether the model, memory, tools, and applications can collaborate effectively on the device over the long term.
Just stacking NPUs isn't enough
The CPU, memory, and software stack must be redesigned together.
In the past, adding an NPU to a CPU or SoC enabled devices to gain AI capabilities such as speech recognition and image processing. But when agents evolve from auxiliary features to the core of a device, simply increasing peak computational power is no longer sufficient.
The reason is that an Agent is not a fixed neural network inference pipeline. Massively parallel computations are best suited for NPUs, while task decomposition, conditional logic, system scheduling, tool invocation, error handling, and multi-system collaboration heavily rely on CPUs. The more dynamic the task path, the more critical the coordination between the CPU and NPU becomes.
Acrab CEO Ken Phua summarized this change as: "CPU is back at the center of the AI era."
In his view, AI is entering a heterogeneous computing environment, where performance depends not only on NPU capabilities but also on whether the CPU and NPU can work together seamlessly.
This is also one of the few team insights worth exploring for Acrab.
Ken Phua previously led the Asia-Pacific applications engineering team at Arm UK and contributed to global IP strategy before serving as co-CEO of Arm China.
This experience matters not just as an industry credential, but explains why this company redefined Agent workloads at the intersection of CPU architecture, heterogeneous computing, and real-world application demands.
Acrab does not define the GΞLIX 1 as a traditional AI processor, but rather as a computing platform for the edge AI era.
On the hardware side, the core is the GΞLIX 1; on the software side, it encompasses large models, an optimized Runtime, a complete toolchain, and an Agent orchestration layer that connects models, tools, devices, and services. Additionally, the company provides reference Agent designs for typical use cases to help developers and ecosystem partners build applications more quickly.
Agent Box is the first time this software and hardware platform has appeared as a complete product. It is defined as a Personal AI Center, capable of running models with hundreds of billions of parameters locally, maintaining core functionality even without an internet connection.
Acrab is derived from the first letters of Agentic Compute, Reasoning, Action, and Brain, and also happens to be the name of a multi-star system in astronomy—reflecting its design philosophy: enabling different computational units to operate in harmony, like stars in a system.
The company aims to equip Agents with a brain capable of thinking and acting, building the next-generation computing platform.
Acrab, headquartered in Singapore, has raised over $350 million in funding to date, with investors including Vertex, the global venture platform under Temasek, and K3 Ventures, a prominent Singaporean tech investment firm.
Its first-generation computing platform, GΞLIX, has been validated in demanding real-world deployment environments and is now moving toward its first industry adoption and mass production.
Funding can buy time for major engineering efforts, but whether the roadmap can succeed ultimately depends on whether the system can be delivered.
From this perspective, "CPU returning to the center" does not mean that NPUs are no longer important.
On the contrary, it means AI computing has become so complex that it can no longer rely on a single isolated accelerator to solve all problems.
Beyond 700 TOPS
Prefill and data pathways determine the real experience.
In many cases, the bottleneck in large model inference is not just that the computational units are not fast enough, but that data cannot be delivered to the computational units in time.
Even if a chip has high peak computational power, the NPU must still pause and wait if the memory bandwidth cannot keep up.
The agent will further exacerbate data transfer issues. It needs to frequently read historical data, pass data between different models and software, and continuously save task states. Each copy increases latency and power consumption; the longer the task runs, the more critical the system design becomes.
The design focus of GΞLIX 1 is to keep as much of the data required by the model as close as possible to the computation unit, while minimizing data transfers between the CPU, NPU, memory, and different operating systems.
According to Acrab’s publicly disclosed architecture, GΞLIX 1 delivers over 700 TOPS of AI computing power and 273 GB/s of unified memory bandwidth, featuring 8 MB of on-chip L1 cache, a shared L2 cache with 768 GB/s bandwidth, four parallel NPU cores, and a dedicated acceleration module designed for Attention computations.
Acrab said the latter can increase computational efficiency by up to three times.
Larger on-chip caches bring critical data closer to the compute units; a shared L2 cache enables efficient sharing of parameters and intermediate features between compute units; and a unified memory architecture reduces unnecessary data copying between the model, operating system, and applications.
Acrab also employs a unified memory architecture across multiple systems, enabling more efficient memory sharing between different operating systems. For devices running only a single model, this may simply be an efficiency improvement; for agents that need to continuously switch between applications and tools, it directly impacts whether tasks can proceed smoothly.
This also explains why Acrab placed Prefill at the center of its launch. Agents often need to reprocess new information when introducing new files, restoring task states, or updating context—the longer the task chain, the more significant the impact of Prefill efficiency on the overall experience.
In a set of self-reported tests by Acrab, GΞLIX 1 achieved a prefill speed of over 1,416 tokens per second when running the 26-billion-parameter Gemma model with a 40K KV cache and a 10,000-token input—more than seven times faster than a leading general-purpose desktop platform under the same load.
Acrab also compared GΞLIX 1 against a comparable desktop-level AI computing platform within the same testing framework.
Data shows that GΞLIX 1 enters a similar performance range in the two core metrics, Prefill and Decode, while offering lower power consumption and a more competitive total system cost.
Acrab's focus on prefill and data pathways reflects a product orientation: edge-side agent chips must not only prioritize how quickly models generate outputs, but also ensure they can rapidly comprehend long contexts, restore task states, and begin working.
Users won’t care how many cache layers are involved in a reasoning pipeline, nor will they check TOPS before every interaction. What they truly experience are just three things: whether it can understand quickly, whether it can run continuously, and whether it’s worth having.
From chip to platform
True competition lies beyond the parameters.
This year at WAIC, Agent Computer, personal AI centers, and enterprise edge devices have not yet formed a unified product form.
Home scenarios emphasize personal memories, content, and device collaboration, while enterprise scenarios prioritize knowledge bases, file processing, and internal data security. Different customers have significantly varying requirements for model size, memory capacity, power consumption, and interfaces.
The more fragmented the endpoints, the harder it is to build a computing platform. A single chip cannot cover all scenarios based on specifications alone; it also requires providing a runtime, model adaptation, development tools, and an agent framework to help customers transform underlying computing power into deliverable products.
This is an additional challenge that Agentic AI chips face compared to general-purpose inference chips: chip performance determines whether the model can run, the software stack determines whether developers can effectively use it, and the agent ecosystem determines what tasks the device can ultimately accomplish. Missing any one layer may leave a chip with impressive parameters stuck at the demo stage.
Acrab is trying to take control of all these stages at once. The benefit is a more complete product definition, but the risk is straightforward: the scope is too broad.
The chip must demonstrate performance, stability, and scalable delivery capabilities; the software stack must keep pace with the rapid iteration of models; and the agent orchestration layer must remain compatible with evolving tools and applications. Once personal files and long-term memory are kept locally, permissions isolation, plugin security, and operational auditing must also be addressed simultaneously.
Therefore, whether Acrab can become the computing platform of the Agentic AI era ultimately does not depend on how many tokens are demonstrated at the launch event, nor on how many tasks the Agent Box can showcase.
More critical validations are: whether developers can rapidly build products on this platform; whether performance, power efficiency, and stability can all be maintained after an Agent operates continuously for hours; and whether the underlying software and hardware can keep pace as the model and Agent framework continue to evolve.
Architectural innovation determines a chip company’s upper limit of capability, while engineering execution and ecosystem determine whether that limit can be turned into orders.
The surge of new terminals on WAIC indicates that the industry is shifting from "getting large models running" to "enabling agents to work continuously." The previous stage focused on computing power, memory, and model size; the next stage must also address long context, personal memory, tool invocation, and multi-task coordination.
Acrab is betting on this very change.
Agent Box is not the end, but a public test of the platform's capabilities.
The edge chip needs to be "redesigned," not because TOPS are unimportant, but because agents are shifting computation from peak numbers to sustained system capabilities. Its success ultimately depends on whether this chip, software, and end device can integrate into real-world workflows.