WorksComputer Science
A Self-Exploring and Self-Evolving Paradigm for Adaptive Edge AI Development
Abstract
Large Language Models (LLMs) exhibit powerful code generation abilities, fostering agentic systems to automate edge AI application development. However, existing agents typically operate via fixed agentic workflows and predefined design spaces, struggling to handle rapidly evolving demands of real-world scenarios (e.g., heterogeneous data modalities, diverse task pipelines). Unlike prior systems that treat LLMs mainly as code generators following rigid workflows, we fully exploit their reasoning capabilities to allow agents to determine their own workflows on the fly. To this end, we propose SE2, a self-exploring and self-evolving paradigm for adaptive edge AI development. Inspired by human learning processes, we distill development into four atomic operations (retrieve, reason, code, test), and empower agents to explore workflows by dynamically and adaptively selecting an appropriate next operation based on the current context. Extensive evaluations show that, with adaptive workflows, the synthesized programs achieve up to 26% higher accuracy and consume 28% lower resources than state-of-the-art baselines, while maintaining superior adaptability to unforeseen edge AI scenarios. This highlights the potential of reasoning-driven adaptive agentic workflow in edge AI development.
Introduction
Edge AI integrates AI techniques with heterogeneous mobile devices to enable perception and actuation in real-world environments [1], [2], [3], [4], [5], [6], facilitating various applications such as smart sensing [7], healthcare [8], [9], and autonomous driving [10], [11], [12], [13].
Developing such applications, however, relies on substantial domain expertise among developers, who must analyze multimodal datasets, design complex signal-processing pipelines, train AI models under diverse constraints, and deploy them on heterogeneous mobile devices [14], [15], [16], [17], [18], [19], [20]. Therefore, recent works [21], [22], [23] build LLM-based agentic systems to automate this process by leveraging LLMs’ code generation capabilities and embedded domain expertise. These systems can translate user requirements into executable edge AI programs based on handcrafted, predefined agentic workflows, chaining modules such as knowledge retrieval,
task planning, code generation, and iterative refinement [24], [25].
Fixed agentic workflows, however, often struggle to handle diverse edge AI tasks in real-world scenarios (Figure 1, left). In practice, edge AI tasks may span numerous mobile devices, heterogeneous runtime environments, and dynamic performance and resource constraints. As our study reveals (§ II-A), even well-engineered agentic systems may struggle to accommodate such variability, suffering from inflexibility, limited adaptability, and high maintenance costs.
Figure 1. Previous works handcrafted fixed agentic workflows to synthesize programs. SE{sup}2` autonomously explores and selects the next atomic operation in program synthesis to meet diverse edge AI requirements.
The root cause is that fixed workflows are often constrained by the specific assumptions and development experiences of workflow designers. In practice, developers must explicitly enumerate workflow steps and handcraft detailed prompts that regulate agent actions for each. As a result, LLMs solely function as code generators following predefined instruction flows. Yet, a key strength of LLMs remains under-explored: their reasoning capabilities, i.e., the ability to make decisions in response to dynamic context information. This gap motivates a key research question: Can we harness LLMs’ reasoning capabilities to autonomously construct adaptive workflows to meet the ever-changing requirements of edge AI development? If successful, we could shift the burden of workflow design from developers to AI agents, enabling more flexible, adaptive, and scalable edge AI application development.
Moving toward such a self-exploring and self-evolving agentic paradigm, we propose SE{sup}2 that leverages LLMs’ reasoning abilities to autonomously construct distinct workflows for various edge AI tasks. The core insight is inspired by human learning processes, which involve iterative knowledge acquisition, reasoning, practice, and reflection on accumulated experiences. Likewise, an SE{sup}2 agent explores its workflow and evolves through iterations of reflection and exploration. Building upon this vision, we distill edge AI development into four atomic operations (retrieve, reason, code, test), which serve as meta building blocks of agentic workflows (Figure 1, right). The agent autonomously selects the next appropriate atomic operation based on its reasoning about the accumulated context, thereby flexibly adapting to diverse edge AI scenarios. In addition, our agent evolves through self-reflection, rather than blindly adhering to rigid workflows.
Nevertheless, three unique technical challenges needed to be addressed, calling for novel design and implementation:
❶ Limited long-context reasoning capability. It is inefficient and impractical to rely on a single agent to perform all the atomic operations due to the limited long-context reasoning abilities of current LLMs, even if they have large context windows [26]. To tackle this, we adopt a coordinator-actor agentic architecture, where a coordinator agent maintains a global view and autonomously orchestrates four task-specific atomic agents, i.e., retriever, reasoner, programmer, and tester. As detailed in § 4, this modular division of cognitive tasks effectively reduces reasoning complexity over long contexts, fostering interpretable and traceable decision-making.
❷ Lack of in-depth understanding of edge devices. Our feasibility study (§ II-B) found that, even augmented with detailed device specifications, LLMs still struggle to generate executable and performant edge AI programs. The root cause is that LLMs lack runtime feedback from real-world mobile devices. Consequently, the generated code often overlooks critical operational semantics and hardware constraints (e.g., CPU architectures, environment affinity, and memory allocation). To address this issue, we propose a mobile runtime feedback mechanism that encodes grounded, runtime-level semantics and conveys them to agents as actionable feedback, thereby closing the loop for optimization and iteration.
❸ Inability to adapt to evolving Edge AI tasks. Simply relying on vanilla LLMs for decision-making cannot cope with the emerging and evolving edge AI environments and tasks. To enhance the adaptability of the coordinator as well as the atomic agents, we adopt reinforcement fine-tuning (RFT) [27] with an ensemble mutual-actor-critic strategy to improve their domain-specific reasoning abilities. In addition, we design several continuously self-evolving graders to assess the reasoning quality in edge AI contexts and provide adaptive feedback to the RFT loop. This approach enables agents to acquire new domain knowledge over time and agilely adjust their workflows to handle unseen scenarios and edge cases.
We fully implement and comprehensively evaluate it against 8 SOTA baselines on an edge AI code-generation benchmark and three representative multimodal edge AI applications (human activity recognition, vision-language understanding, and autonomous driving), spanning distinct modalities, reasoning complexity, and real-world constraints. Extensive experiments reveal that baseline coding agents cannot consistently generate performant
code (40% success rate lower than ). In contrast, achieves up to 26% higher accuracy and 28% reduction in resource consumption compared to SOTA methods, while retaining superior generalizability across tasks. These results validate the effectiveness of our reasoning-driven adaptive workflow construction paradigm.
In summary, we make the following contributions:
exploits LLMs’ reasoning capabilities to autonomously construct agentic workflows via self-exploration and self-evolution, addressing the limitations of fixed workflows in heterogeneous and evolving edge AI environments.
We design a reasoning enhancement framework featuring atomic-operation-level adaptive agentic workflow construction, runtime-grounded probe synthesis, and continual multi-agent reasoning evolution.
We implement and extensively evaluate against eight SOTA agents on a public benchmark, three representative multimodal edge AI applications, and through a user study, demonstrating its superior accuracy and generalizability.
Background & Motivation
Limitations of SOTA Methods
By equipping LLMs with external tools (e.g., search engines), we can build agents [28], [29], [30], [31], [32], [33], [34], [35], [36], [37] and design agentic workflows guiding them to automatically solve complex tasks. As shown in Figure 2, an agentic workflow is typically a multi-step process where each step receives the output from the previous step and produces a new intermediate result. With carefully crafted prompts and tool usage rules in each step, the agent can follow the workflow and synthesize various executable edge AI programs for users.
Figure 2. A typical agentic workflow of existing work with detailed step 2.
To better understand the limitations (i.e., inflexibility, limited adaptability, and high maintenance costs) of existing agentic workflows, we conduct a preliminary study by reproducing three SOTA works for edge AI development: AutoIOT [21], AutoEmbed [22], and IoTPilot [38]. These methods adopt predefined workflows involving background knowledge retrieval, task decomposition, code generation, and debugging.
We ask them to develop a human activity recognition system (HAR) using the multimodal XRF55 dataset [39] and repeat 100 times to avoid randomness. We randomly remove data to simulate the modality missing issue in real-world multimodal scenarios [40]. As shown in Figure 3(a), only 32% of the synthesized programs of SOTA methods can be successfully executed, and only 8% achieve comparable performance to a SOTA handcrafted program. It is highly challenging to design a fixed, one-size-fits-all workflow to adapt to unforeseen cases and accommodate diverse edge AI requirements. Further inspection reveals heterogeneous issues:

Figure 3. (a) Existing agentic systems typically fail to handle unforeseen scenarios (b) Though feasible, most agents exhibited limited reasoning capabilities
No unimodal verification: They do not verify the correctness of each code snippet for unimodal data processing before multimodal fusion. This is often discouraged in current multimodal application development pipelines [41].
No handling of missing modalities: 68% of the programs fail when certain data streams are absent due to the lack of elastic AI models for dynamic input handling [40].
To remedy the above as well as other heterogeneous failures, developers have to repeatedly revise and refine their workflows by explicitly listing regulations such as tool usage rules, edge-case handling advice, and consistency checks. Maintaining such crafted rules for unseen scenarios with diverse requirements becomes highly time-consuming and error-prone.
Motivation & Feasibility Study
Motivation. The root cause of these limitations is that the workflow design and its underlying reasoning still heavily rely on human developers, while LLMs are merely treated as code generators following predefined instructions. As a result, these fixed workflows cannot adapt to new tasks in practical real-world scenarios. Unlike SOTA methods, SE² exploits LLMs’ reasoning abilities to enable agents to autonomously optimize and adjust their own workflows in response to diverse goals.
We analyze over 30 agent-based code generation systems and find that nearly all edge AI development workflows are composed of four atomic agentic operations:
retrieve: An agent retrieves relevant domain knowledge from various data sources (e.g., databases, websites).
reason: An agent analyzes the current and past state based on the available information and makes inferences before selecting the next operation. This operation relies on the agent’s reasoning capabilities for decision-making.
code: An agent generates a Python1 code snippet.
test: An agent generates test cases, deploys the code snippet on the target mobile device (optional), executes and evaluates it, and records the evaluation results.
By enabling AI agents to autonomously select among these operations in response to changing states, agentic workflows can be organically constructed. Similar to next token prediction in LLMs, SE² instead predicts the next atomic operation that drives the workflow forward. Feasibility & Challenges. We build a single agent to test whether it can construct workflows autonomously. We instruct the agent to synthesize a multimodal HAR program and deploy it on a Jetson Nano board. We repeat the test 100 times and find that certain constructed workflows can sometimes generate executable edge AI code with satisfactory performance after multiple trials. Notably, they share a similar and commonly adopted structure: ”retrieve knowledge → generate code snippets → test individually → multimodal fusion → build elastic AI models → iteratively refine”. This implies that adaptive workflow is feasible. Despite this feasibility, the overall success rate remains low (8/100), comparable to directly running existing agents without modification. Further in-depth analysis reveals that the failures stem from three fundamental reasoning limitations (Figure 3(b)), precisely motivating the technical challenges that SE² need to overcome:
Long-Context Reasoning. 16 agents repeatedly execute the same action (e.g., searching dataset information) and fail to terminate. It is likely because a single agent performs all operations and accumulates increasingly long contexts, while LLMs inherently pay more attention to the earliest and most recent tokens in the context window, causing the agent to ”forget” previously executed steps [43].
Runtime-Aware Reasoning. Even with retrieved knowledge of the target device, 18 agents still produce error code either because the required runtime environments are incompatible with the device or because the resource consumption exceeds the device’s capacity. The reason is that the agent cannot access the device and thus lacks an in-depth understanding of its runtime environments [44] and resource constraints.
Outdated Models. 58 agents adopt overly general or outdated algorithms and AI models. This indicates that LLMs lack the reasoning capabilities to associate user requirements with SOTA edge AI algorithms and models.
To address these challenges, we design and implement a series of novel techniques as detailed in § IV.
SE² Overview
SE² aims to enhance and exploit LLMs’ reasoning abilities to dynamically and adaptively construct agentic workflows, which translate user requests into executable edge AI code on target devices. As shown in Figure 4, SE² has two stages: 1) self-exploration for dynamic workflow construction, and 2) self-evolution for runtime feedback and continuous LLM tuning.
Figure 4. The overall architecture and workflow of SE² (with detailed operations in step 3).
Self-Exploration. Given a user-requested edge AI task (❶), the coordinator iteratively determines the next appropriate operation. At each step, the coordinator analyzes the output from the previous operation (❷), and generates the next atomic operation with detailed instructions (❸). The corresponding atomic agent is activated (❹) to execute the operation based on the instruction and generate an output (❺), which is further sent to the coordinator (❻). Based on the currently constructed workflow, the coordinator decides if extra operations are required (❼) or concludes that the synthesized edge AI program meets the user requirement with acceptable performance (❽). In addition, SE² provides an interface for users to offer instructions for workflow refinement (❾). As such, agentic workflows are autonomously determined with minimal user intervention, offering enhanced flexibility and adaptability. Note that to better interpret user intents, we can orthogonally integrate existing arts (e.g., LLM-as-a-Judge [45]).
Self-Evolution. When the target device runs the generated code, the mobile runtime feedback mechanism synthesizes a probe to extract runtime semantics (e.g., memory allocation) as grounded, runtime-level feedback. In parallel, our continuous LLM tuning paradigm records the mutual feedback between the coordinator and atomic agents to incrementally enhance their reasoning capabilities in the edge AI domain. As such, all agents can continuously evolve, enabling them to adapt to unforeseen scenarios and emerging edge AI knowledge.
Detailed Design of SE²
Hierarchical Coordinator-Actor Agentic Architecture
This module performs self-exploration by dynamically constructing adaptive workflows. Due to LLMs’ limited long-context reasoning abilities (§ II-B), we propose a coordinator-actor agentic architecture, where a coordinator agent orchestrates the self-exploring process by delegating distinct tasks to four atomic agents: retriever, reasoner, programmer, and tester. This design offloads the execution of atomic operations to multiple task-specific agents for more efficient handling.
Challenge. In multi-agent systems, sharing contexts among agents often leads to prohibitive costs [46], introducing a new challenge: how to enable effective and efficient communication between the coordinator and atomic agents while ensuring context coherence? To address this, we design tailored prompts to regulate each agent’s behavior and outputs.
P. 1: Coordinator Prompt (step transition prompt, simplified)
❶ Role & Objective: You are a coordinator agent operating in a multi-agent system for edge AI development. Given a user requirement, you need to orchestrate another four atomic agents (retriever, reasoner, programmer, and tester) to synthesize an executable program.
❷ Respond Rules: You MUST select one of the following operations:
Retrieve – activate the retriever to retrieve relevant knowledge
Reason – activate the reasoner to analyze and reflect on ...
Code – activate the programmer to write a Python script ...
Test – activate the tester to execute and evaluate the code ...
Quit – end the task if the code satisfies the user requirement.
❸ Current State:
The summarized activity of atomic agent: {.....}
❹ Output Specifications: You MUST generate ONLY THREE items:
Operation Name – the name of the atomic operation for execution.
Instructions – a brief instruction for the corresponding agent.
Context – detailed context including previously generated ...
❺ Simple Example Response
[retriever] Retrieve detailed information of the {dataset name} dataset.
I need to understand the dataset first, including dimension-ality, ......
Coordinator Prompt (P.1) for step transition includes:
Role & objective. We assign the agent a coordinator role and provide a task description that guides it to proactively orchestrate multiple agents for edge AI development.
Respond rules include descriptions of the four atomic operations and their selection rules. We task the coordinator with iteratively selecting an appropriate operation and activating the corresponding atomic agent for execution. We also introduce a quit operation that ends self-exploration if the generated code meets the user requirement. Importantly, beyond sticking to the general cycle of ”retrieve → reason → code → test”, we encourage the coordinator to repeat any stage as needed, e.g., ”retrieve → reason → retrieve”.
Current state. Atomic agents’ activities are recorded during operation execution, serving as the current state and thereby enabling the coordinator to determine the next operation with enhanced contextual coherence.
Output specifications. To ensure that atomic agents can accurately interpret the operation, we stipulate that the coordinator only outputs three items: the operation name, a brief instruction, and relevant context information.
One-shot example. We provide a sample output to reduce ambiguity in task interpretation.
P. 2: Atomic Agent Prompt (simplified) (Example: retriever)
❶ Role & Objective: You are a retriever agent operating in … Based on the provided information, you need to retrieve relevant information from external data sources (e.g., websites).
❷ Operation Execution Rules: You MUST follow these rules:
You MUST invoke multiple tools to complete the instruction …
You MUST retrieve as much information as possible before …
You MUST summarize the retrieved content and store it …
❸ Output Specifications: Your MUST output one of the types below:
function_call – you need to invoke tools to gather information or …
message – directly output ”[finish_retrieval]” if you believe that …
❹ Instruction & Context Information: {coordinator_instruction} {context_information}
Atomic Agent Prompt (P.2) comprises four parts:
Role & objective. We also assign distinct roles to the atomic agents, along with descriptions of their jobs.
Operation execution rules. We encourage each atomic agent to proactively and repeatedly invoke relevant tools to obtain sufficient information or conduct thorough tests.
Output specifications. We stipulate that each atomic agent can only respond with a function_call with parameters to invoke a tool, or a message to quit the current operation.
Instruction & context information from the coordinator. We instruct atomic agents to invoke tools until all necessary information is gathered. Once a ”finished” message is generated, the atomic agent’s activity is summarized and returned to the coordinator for further decision-making.
Remarks. Through our coordinator-actor agentic architecture with crafted prompts, the coordinator can autonomously explore appropriate atomic operations based on its reasoning abilities. As such, agentic workflows can be dynamically constructed to cope with unforeseen cases (e.g., modality missing), exhibiting enhanced flexibility and adaptability.
Mobile Runtime Feedback Mechanism
This module facilitates self-evolution by providing runtime-level feedback for decision adjustment. As detailed in § II-B, even with retrieved device information, some generated code remains unexecutable, as SE² cannot directly access devices and lacks detailed runtime signals during coding and testing. Thus, we propose a mobile runtime feedback mechanism that obtains grounded, runtime-level semantics as timely feedback.
Challenge. An intuitive way to extract runtime semantics is to apply existing device profiling techniques (e.g., nn-Meter [47]). However, they rely on rule-based scripts for runtime monitoring, which are often insufficient for diverse and rapidly evolving edge AI tasks. Instead, SE² synthesizes probe programs that execute on the target device to extract only relevant runtime semantics. Our insight is that the coordinator, overseeing the entire development process, can serve as a supervisor for probe synthesis. The runtime semantics collected by the probe are then fed back to atomic agents for response adjustments. Specifically, we design: probe synthesis, semantic alignment grading, and response adjustment.
Probe Synthesis. Different from general code generation, the purpose of a probe is not to solve the coding task, but to extract latent runtime semantics that agents cannot infer from textual device specifications. Specifically, we prompt (P.3) the coordinator to synthesize a probe program with two main considerations before on-device code execution:
Runtime semantics. Environment affinity reveals incompatibilities between library versions and hardware kernels. Memory dynamics reflect feasibility under runtime allocation and fragmentation patterns. Execution behavior exposes performance bottlenecks arising from scheduling, warm-up, and accelerator utilization. I/O feasibility verifies if essential data formats are supported.
Probe program requirements. Minimality ensures that each probe focuses on a single runtime factor, reducing confounding effects and enabling precise interpretation of observed behavior. Orthogonality prevents probes from blending unrelated concerns, preserving the diagnostic clarity for targeted adjustments. Executability guarantees that each synthesized probe can reliably run
within the device’s native software stack and provide grounded evidence. Observability mandates that probes emit structured outputs, enabling the system to consistently extract useful runtime semantics.
P. 3: Probe Synthesis Prompt (simplified)
❶ Role & Objective: You are a probe-synthesizer. Your goal is to develop a probe program that extracts relevant runtime semantics ...
❷ Runtime Semantics. (tailored to the coordinator’s instruction):
Environment affinity; (e.g., PyTorch versions, CUDA/cuDNN bindings)
Memory dynamics (e.g., allocation failure, fragmentation, peak usage)
Execution behavior (e.g., latency, warm-up stability)
I/O feasibility (e.g., data loading, sensor interface availability)
❸ Probe Program Requirements:
Minimality; 2. Orthogonality; 3. Executability; 4. Observability
❹ Instruction & Context Information: {coordinator_instruction} {context_information}
Semantic Alignment Grading. Based on the runtime semantics obtained from the probe, we need to judge if each atomic agent’s decision aligns with the current device runtime and the edge AI requirement. Such semantic alignment manifests in two aspects: 1) Local alignment: whether the atomic agent’s response contributes to the agent’s current task, i.e., the coordinator’s instruction; 2) Global alignment: whether it contributes to the coordinator’s overarching task, i.e., the user requirement. We prompt the coordinator to assign two scores reflecting the local and global alignment of each atomic agent’s response based on six designed grading levels. In addition, we instruct the coordinator to provide feedback for atomic agents to adjust their responses. For example, ”The code should use a smaller batch size to reduce memory usage and employ TensorRT to accelerate on-device inference”. As such, the grading process for response is expressed as:
where and are the local and global semantic scores, and and are the corresponding feedback, respectively. is the coordinator’s instruction. is the atomic agent’s activity record during operation execution. is the user requirement. is the runtime semantics obtained from the probe. The scores and dialogue will be stored in a dataset :
which will be further used for continuous tuning (§ 4-C).
Response Adjustment. Considering both the current state and the feedback from the coordinator, we prompt the atomic agent to adjust its response and regenerate a better one: . Note that we do not request agents to regenerate if the semantic score exceeds four, as the response is sufficiently aligned with the intended task, exhibiting only minor flaws that do not impact overall coherence [48].
Remarks. We leverage the coordinator to provide guidance grounded in mobile devices’ runtime constraints, enabling atomic agents to adjust responses that better align with both the current operation and the overall user requirement.
Continuous LLM Tuning Paradigm
This module performs self-evolution by continuously tuning all the agents to enhance their reasoning about evolving edge AI knowledge. We focus on three aspects of enhancement: 1) The coordinator’s cognitive reasoning to autonomously select the next appropriate operation. 2) Atomic agents’ operation execution abilities. 3) The programmer’s domain-specific reasoning abilities to interpret edge AI knowledge and generate relevant algorithms. Though building a RAG database [49] is promising, its timely maintenance demands substantial domain expertise, and vanilla LLMs still require strong reasoning abilities to comprehend the new knowledge [50]. In contrast, we adopt a modified reinforcement fine-tuning (RFT) [27] strategy to enhance agents’ reasoning abilities in edge AI without user intervention, which can enhance LLMs’ reasoning capabilities in specific domains by tuning on smaller amounts of data.
RFT Procedure. Unlike supervised fine-tuning [51, 52], [53] that forces LLMs to generate precise answers, RFT relies on a grader that scores generated responses, followed by policy gradients to refine LLM parameters [54]. RFT mainly consists of three stages: 1) Grader design. A grader is created to score the quality of LLM outputs. Generally, graders can take various forms, such as format checkers, Python code, or even LLMs [27]. 2) Dataset construction. We first prepare a question set, , with an expected answer set, , and input into the LLM, , to obtain a generated answer set, . Accordingly, we prompt the grader, , to score each answer. The tuning dataset, , is thus obtained as a set of questions, expected answers, generated answers, and scores, :
Fine-tuning. With the obtained training dataset, policy-gradient updates (e.g., VPG [54]) are adopted for LLM tuning:
where is the policy gradient, is the dataset cardinality, are LLM parameters, are the advantage estimates [55] based on the grader, and is the learning rate. After several epochs, RFT enhances the reasoning capabilities of LLMs by encouraging them to generate high-scoring outputs more frequently while suppressing low-scoring ones.
Challenges. Directly adopting RFT in SE faces two main challenges: 1) Assessing the continuously evolving coordinator and atomic agents necessitates multiple evolving graders. 2) Grading the programmer demands complicated analysis of both the quality and performance of the generated code across diverse edge AI algorithms. To tackle these issues, we propose: 1) An ensemble mutual-actor-critic strategy to enhance both the coordinator and atomic agents in a mutual-critique manner. Our insight is that both the coordinator and atomic agents can function as graders to criticize each other’s behaviors from distinct perspectives. 2) A self-reflective grader to further critique the programmer, considering both code performance and algorithm specialization to the edge AI domain.

Figure P. 4. Coordinator Grading Prompt – by retriever (simplified)
Ensemble Mutual-Actor-Critic Strategy. We augment the actor-critic algorithm [56] with an ensemble updating strategy to refine both the coordinator and atomic agents. As shown in Figure 5, to update atomic agents, we treat the coordinator as the grader to criticize atomic agent behaviors. In turn, to refine the coordinator, we regard atomic agents as four separate graders, each criticizing the coordinator from a distinct angle regarding their specific tasks. Thus, both the coordinator and atomic agents can be mutually updated as self-exploration progresses. Given the dataset in Equ. 2 containing the scores for the atomic agents, their tuning processes are expressed as:
Figure 5. Ensemble mutual-actor-critic strategy.
where is a linear combination of both local and global semantic scores graded by the coordinator. To tune the coordinator, we first design four tailored grader prompts for atomic agents to rate the current atomic operation and instruction generated by the coordinator. Taking the retriever as an example, the grading prompt (P.4) considers both the correctness and necessity of the coordinator’s decision. An ensemble score is then calculated via weighted aggregation:
where is the current operation, is its assigned weight, and is the score rated by each atomic agent. If does not match the atomic agent’s operation, we compute the score as , as in this case, a higher score means that the atomic agent considers its own operation to be more appropriate. The coordinator is then updated using the ensemble score:
Such an ensemble strategy allows bidirectional critique between the coordinator and atomic agents during self-exploration, thereby fostering reflection on accumulated context and enabling continuous, iterative self-evolution. Self-Reflective Grader for Edge AI. To further enhance the programmer, we consider three main aspects:
Code quality includes syntax correctness and code smells, which are bad coding styles (e.g., no exception handlers) or potential weaknesses (e.g., deprecated packages) [57]. They can be scored by SOTA code quality inspectors.
Code performance is tested by prompting the tester to produce test cases and assess performance across multiple evaluation metrics. The tester is further prompted to assign a score to comprehensively reflect the results.
Algorithm specialization: Whether the programmer uses tailored algorithms to process sensor data. For instance, Butterworth filtering is commonly applied to Wi-Fi CSI data to suppress noise induced by non-human activities.
We prompt the programmer to first identify a list of sensor data processing algorithms used in the generated code. For each algorithm, we prompt (P.5) the programmer itself to grade it on a scale from 1 (completely mismatched) to 6 (fully tailored) based on how closely the algorithm aligns with established, modality-specific methods. Higher scores indicate stronger adherence to domain-relevant practices, and lower scores reflect reliance on generic or unsuitable approaches. This process exploits the self-reflection capability of the programmer, with the reflection score further used in RFT to facilitate self-evolution. Then the final score is:
where is the code quality score, is the code performance score, is the -th algorithm specialization score with corresponding weight . Note that all tuning is performed entirely offline, without interfering with the online code generation.

Figure P. 5.
the rest to 200 coding tasks. Each task contains a ”task specification → edge AI code” pair with curated test cases, each corresponding to a specific functional requirement in the specification. We randomly split the augmented benchmark into two parts: 20% for tuning and 80% for testing (RFT requires less tuning data). The tuning and testing data have completely different tasks.
Multimodal Edge AI Applications: Considering different developing pipelines, data processing algorithms, sensor modalities, and device heterogeneity, we select three representative multimodal edge AI applications for evaluation:
❶ Human Activity Recognition (HAR) using the XRF55 dataset [39], containing 42.9K samples and 55 action classes of various human daily activities. Three modalities are involved: RFID, Wi-Fi CSI, and mmWave. We request deployment on a Raspberry Pi with no GPU and only 8GB RAM.
❷ Vision-Language Understanding (VLU) using the MMMU dataset [62] for image Q&A. There are two modalities in the dataset: image and text. We request deployment on a Jetson Nano board, which has a different runtime environment from the local server where SE operates.
❸ Object Detection in Autonomous Driving (ODAD) using the aiMotive dataset [63] in 176 scenes. This task is the most complex, as it involves four modalities (1 LiDAR, 2 radars, 4 cameras, and 1 GNSS+INS) with high dimensionality, necessitating advanced data processing algorithms and AI models. Besides, we randomly remove some data modalities to simulate the modality missing issue in real-world scenarios.
Baselines: We compare SE with 8 SOTA baselines:
General coding LLM: GitHub Copilot [64] suggests code snippets and functions following user instructions.
General coding agents (fixed workflow): MapCoder [65], AgentCoder [66], AgentSquare [24].
Coding agents tailored to mobile tasks (fixed workflow): AutoIOT [21], GPIOt [50], IoTPilot [38], AutoEmbed [22].
Experiment Setup
Implementation
We fully implement SE using o4-mini [58] as the internal LLM for balanced reasoning and response latency. The initial tool pool contains a Tavily-based search engine [59], a Chroma-based database [60], a Python executor inside a sandbox, a Pylint-based code quality inspector [61], and a tool builder that allows agents to dynamically create new tools. We carefully design all graders and adopt RFT following OpenAI’s official guidelines [27]. We develop SE with 5,288 lines of Python code and deploy it on a local server. The generated code is tested and deployed on various mobile devices, including portable laptops, Jetson Nano, and Raspberry Pis, which are connected to the local server via a router.
Evaluation Protocols
We use both a SOTA benchmark and three representative edge AI applications for comprehensive evaluations. The benchmark provides a controlled setting for measuring core capabilities, while the real-world edge AI cases investigate the system’s effectiveness and adaptability in practical scenarios. In addition, we conduct a user study to evaluate the generalizability of SE, where we invite users to propose diverse improvisational requirements (including unseen applications).
Benchmark: We use IoTBench [50], a tailored benchmark to assess LLMs’ abilities in generating IoT-relevant code. We filter out data irrelevant to edge AI and augment
Evaluation
Benchmark Evaluation
Metrics: Code similarity: we convert code into embeddings that capture its internal logic via CodeT5+ [67]. We compute the cosine similarity between the embeddings.
of the generated and the reference code (from IoTBench). A higher value indicates a stronger ability to generate edge-AI-related code. Pass@k: measures the probability that at least one of the top-k generated programs passes all functional test cases [68]. A high value indicates accurately interprets tasks and passes more functional test cases from IoTBench. Code quality: we use Pylint [61] to assess code quality.
Performance Comparison: As shown in Figure 6, we find:

Figure 6. Performance comparison on IoTBench (SE: SE, GC: GitHub Copilot, MC: MapCoder, AC: AgentCoder, AS: AgentSquare, AI: AutoIOT, GT: GPIOt, IP: IoTPilot, EG: AutoEmbed).
can effectively generate functionally correct and performant code tailored to edge AI following task specifications. On average, achieves an 11% higher code similarity score and a 17% higher pass@1 rate than baselines. The gain in pass@5 rate (10% ↑) is relatively small because it has higher fault tolerance than pass@1.
Interestingly, general coding agents (GitHub Copilot, MapCoder, AgentCoder) exhibit lower performance in terms of code similarity (14% ↓) and pass@1 rate (25% ↓), indicating that general coding agents are incapable of generating high-quality edge AI programs. For instance, they all directly apply AI models on the raw Wi-Fi CSI data without dedicated processing (e.g., Butterworth filtering [69]) to remove noise induced by non-human activities in HAR.
In contrast, IoT-tailored agents (AutoIOT, GPIoT, IoTPilot, AutoEmbed) perform relatively better, owing to tailored designs such as RAG. In addition, AgentSquare achieves comparable pass@5 performance to , due to its iterative workflow optimization method. However, we find that it requires much more time to generate performant code (§ VI-B).
significantly outperforms the baselines in code quality by an average of 1.6 points. The reason is that our self-reflective grader uses code quality as a grading metric. Thus, after RFT, the programmer gains enhanced abilities to produce high-quality code while adopting edge-AI-relevant algorithms. Notably, GitHub Copilot achieves higher code quality scores than other baselines, as it uses tailored LLMs and prompts for high-quality code generation, whereas other agents typically rely on vanilla LLMs. In general, the superior performance of stems from its self-exploration abilities in adopting SOTA algorithms dedicated to various edge AI tasks.
Case Study on Edge AI Applications
Metrics: We repeat the test 100 times and calculate the average values of the following metrics: Classification accuracy (HAR): the portion of the correctly classified activities. Answer correct rate (VLU): the portion of the correctly answered image Q&A pairs. Precision (ODAD): the portion of the detected bounding boxes that are actually correct. Memory consumption: the CPU RAM or GPU VRAM usage during code execution. Inference time: the time used for processing a single multimodal data batch on the target device. Execution success rate: the portion of the programs that can be successfully executed. Wall-clock generation time: the time from the user’s request to the final program synthesis.
Evaluation on HAR: We request that the multimodal HAR model be executed on a Raspberry Pi (8GB RAM, no GPU). As shown in Figure 7, outperforms baselines in terms of success rate (39% ↑) and classification accuracy (26.5% ↑). We find that first generates a script to obtain the data dimension, which is not specified in the requirement, indicating that learns to fetch such important yet missing information via self-exploration, rather than relying on explicit workflow engineering by developers. In contrast, the baselines’ fixed workflows often get stuck in handling unspecified data dimensions. Further, by decomposing the task into multiple subtasks, can independently generate, test, and refine code snippets for each, ultimately achieving higher accuracy.

Figure 7. Performance comparison on HAR.
Most GitHub-Copilot-generated code cannot be executed, while executable ones achieve only 34% accuracy on average. The reason is that GitHub Copilot is designed for general-purpose coding and lacks specialized designs. Thus, it cannot effectively produce tailored edge AI code. This phenomenon is consistently observed across distinct edge AI tasks and is exacerbated as the task becomes complex (Figure 8 & Figure 9).

Figure 8. Performance comparison on VLU.

Figure 9. Performance comparison on ODAD.
Moreover, -designed models consume moderate memory with acceptable inference latency (Figure 7(c)). Though AutoIoT and GPIoT adopt thorough model optimization methods (e.g., pruning [70]) to reduce memory cost to 2GB, the resulting accuracy is much lower than . In addition, IoTPilot and AutoEmbed sometimes achieve lower performance, likely because they are more tailored to embedded tasks.
Lastly, only needs 43 minutes for code generation, slightly surpassing other agents that use fixed workflows.
While GitHub Copilot and GPIoT take only a few minutes with a few rounds of LLM calls, most generated code is unexecutable. AgentSquare has a 13% lower success rate and takes a much longer time (90 minutes) to generate executable code, as it exhaustively searches over large module spaces.
Evaluation on VLU: We request to deploy the VLU model on Jetson Nano. Unlike the x86-based PC where operates, Jetson Nano uses ARM CPUs with a distinct runtime environment for on-device deployment. Thus, agents must realize this case and adopt an appropriate inference engine to ensure compatibility with Jetson Nano.
As shown in Figure 8, outperforms baselines in terms of both success rate (52.8% ↑) and answer correct rate (23.9% ↑). Notably, the success rate of baselines drops dramatically compared to HAR. After analyzing their intermediate outputs, we find that they all ignore runtime differences and repeatedly attempt to deploy x86-based models on ARM-based Jetson Nano, as their fixed workflows ignore runtime heterogeneity. In contrast, realizes this issue by proactively analyzing the runtime semantics obtained from the probe program. Then, creates a few more agentic steps to convert the model into a platform-agnostic ONNX format [[71]] and use TensorRT [[72]] compatible with Jetson Nano for model inference. Besides, AgentSquare needs substantial time for workflow optimization (Figure 8(d)). The accumulated context causes the agent to forget the device’s memory constraints (4GB VRAM), producing models consuming over 10GB of VRAM (Figure 8(c)).
Evaluation on ODAD: We request deployment on an edge laptop with 16GB VRAM. This task is highly complex as it involves four modalities of high-dimensional data. Besides, we randomly remove some data to simulate modality missing occurred in real-world autonomous driving scenarios. Agents ought to account for this unforeseen case and build elastic AI models capable of processing input data of varying sizes.
As shown in Figure 9, outperforms baselines with a significant 50% higher success rate. After reviewing its workflows, we find that though initially creates a model that fails to support elastic inputs, it discovers this flaw during testing. then agilely adjusts its workflow and modifies the model to cope with varying input data sizes. Such developing pipelines closely resemble humans, exhibiting remarkable adaptability of in handling unexpected cases. In contrast, the baselines repeatedly refine the code by randomly adopting other data processing methods without being aware of the crux. Consequently, they spend more time on debugging and produce high-memory-cost models that fail to meet resource constraints.
Ablation Study
To separately test the impact of distinct modules, we conduct an ablation study on multimodal HAR, with similar phenomena being observed in other applications. Note that the superior performance of compared with the single-agent setting in § II-B has demonstrated the importance of our coordinator-actor agentic architecture.

(a) Overall performance

(b) Long-term evaluation
Figure 11. Evaluation results of the user study.
Mobile Runtime Feedback Mechanism. We test 3 ablation cases: , without the probe but replaced by a widely adopted runtime monitor psutil [73], and without any feedback. Figure 10(a) reveals that without full feedback, experiences a significant 66% drop in success rate and requires twice as long to generate executable code. Without probe-collected runtime semantics, the coordinator cannot provide useful feedback to atomic agents, and thus cannot identify if the code is well aligned with the device’s runtime environment. Though psutil can provide detailed runtime information, often struggles to extract content relevant to current coding subtasks, leading to a 1.5x increase in synthesis time. These results highlight the importance of our feedback mechanism in providing runtime semantics grounded in mobile devices.

Figure 10. Ablation study (F. − feedback mechanism, E. − ensemble mutual-actor-critic strategy, S. − self-reflective grader, C. − continuous LLM tuning).
Continuous LLM Tuning. We test 4 ablation cases: , without the ensemble mutual-actor-critic strategy, without the self-reflective grader, and without continuous tuning. In Figure 10(b), all modules are crucial for retaining a high success rate and reducing code generation time. Without the mutual-actor-critic strategy, the coordinator and atomic agents cannot be mutually updated, resulting in obsolete reasoning abilities when facing new edge AI knowledge and tasks. Without the self-reflective grader, the programmer cannot reflect on its generated algorithms and continuously evolve to produce edge-AI-relevant code. These results show the effectiveness of our continuous LLM tuning paradigm in enhancing agents’ reasoning abilities for edge AI progressively.
User Study for Generalizability Test
To assess the utility and overall user satisfaction, we conduct a user study2 involving 10 expert users and 10 non-expert users. Expert users have rich experience in sensor data processing and AI technologies, while non-expert users only possess basic knowledge of edge AI applications. Importantly, to test the generalizability of , we did not limit the tasks. Instead, users are encouraged to freely express their requirements for developing various edge AI applications. Table I lists the detailed background information of the participants.
| Category | Background Information |
| Gender | Female (45%), Male (40%), Prefer not to say (15%) |
| Age | Under 18 (5%), 18-30 (75%), 30-39 (10%), 40 and older (10%) |
| Education | Bachelor (5%), Master (20%), Doctoral (70%), Others (5%) |
| English | Fluent (10%), Advanced (65%), Intermediate (20%), Beginner (5%) |
Table I. Participant information of user study (N=20)
Metrics: Overall code performance (OCP) evaluates the overall performance (e.g., accuracy, resource consumption) of the generated code; Code readability (CR) measures the code clarity and structure; Generation efficiency (GE) accesses how efficiently is when producing the final code; Code modularity (CM) judges if the code is properly modularized for easy reuse and extension; User satisfaction (US) captures users’ overall experience with . We ask users to rate these metrics on a scale from 1 (not at all) to 5 (completely).
Overall Performance: Users’ improvisational requests span a range of edge AI topics: mobile sensing (40%), actuator control (40%), and personalized services (20%). Experts often challenge with more complex tasks (e.g., multimodal emotion analysis) while non-experts tend to propose simple tasks (e.g., IMU-based HAR). In Figure 11a, both experts and non-experts provide high scores (above 4.7) for OCP, CR, CM, and US. Notably, nearly all users give CR full marks. After analyzing the generated code, we attribute it to the hierarchical agentic architecture, where distinct agents exploit their own reasoning abilities to progressively generate modular code for various functionalities. This process is akin to how humans divide a task into multiple modules and generate modular code for each. Besides, experts tend to rate GE lower than non-experts, as they are knowledgeable in edge AI and have higher expectations for system performance. Despite this, GE increases as system utilization grows (§ VI-D3), benefiting from the continuous tuning paradigm. These results exhibit the generalizability of in exploring distinct workflows for diverse edge AI tasks with enhanced user experience.
Long-Term Evaluation: We further ask expert users to join in long-term evaluations to test the impact of the self-evolving paradigm. Figure 11b shows that as user engagement increases over time, both GE and US rise with a similar growth trend. As system usage time increases, the scores graded by the coordinator and atomic agents gradually accumulate and are used in mutual critique to enhance reasoning. Moreover, the retriever progressively stores new knowledge in the local database for reference. When new similar tasks occur, can activate fast thinking to make decisions rapidly without re-exploration, leading to shorter generation times. Notably, though initially tends to adopt hallucinated algorithms, they are corrected by the feedback mechanism, and the likelihood decreases as RFT progresses. These results demonstrate the outstanding self-evolving abilities of in handling diverse user tasks and new edge AI knowledge.
Discussion
Robustness and Reliability. relies on LLMs, which may produce hallucinations during multi-step reasoning. To mitigate this issue, incorporates Reflexion [74], which reflects on failed attempts and evolves iteratively. The significantly higher execution success rate (§ VI-B) validates the practical reliability of . Moreover, to further enhance the robustness of in detecting and recovering from mistakes, we plan to integrate self-reflection techniques like ReAct [75] as future work.
Generalizability. In the user study, we invited 20 participants with distinct expertise in edge AI development. Admittedly, recruiting a large cohort of more diverse participants could more comprehensively evaluate both overall and long-term performance. In order to evaluate external validity (i.e., generalizability to diverse user requirements), we asked the participants to propose improvisational requirements. The evaluation results (§ VI-D) demonstrate the generalizability of in handling diverse edge AI tasks.
Vibe Coding vs. . Vibe coding refers to using LLMs to generate code snippets purely from user instructions, without execution and verification [76]. Users must manually design multiple prompts and verify the correctness of all generated code. In contrast, provides an end-to-end solution that automatically translates user requests into executable, runtime-compatible, and performant on-device code. By fully utilizing LLMs’ reasoning abilities, autonomously determines and adaptively adjusts workflows for robust edge AI development.
Related Work
Agents & Code Generation. By equipping LLMs with various external tools, AI agents can automate complex tasks, such as phone manipulation [29] and IoT data interpretation [77]. Many works build automated agents to synthesize various IoT programs. For example, AutoIOT [21] generates IoT programs through IoT knowledge retrieval and iterative refinement. AutoEmbed [22] introduces a hardware-in-the-loop paradigm that enables agents to flash generated code onto embedded devices. However, developers must meticulously design and optimize agentic workflows to ensure that agents can follow explicitly predefined guidance, limiting their flexibility and adaptability. Instead, exploits LLMs’ own reasoning abilities to dynamically construct workflows.
Agentic Workflow Optimization. Some studies [25, 78] focus on automated optimization of predefined workflows to reduce human effort. For instance, ADAS [25] and AgentSquare [24] regard predefined workflows as combinations of various agentic modules (e.g., Chain-of-Thought [79] and Tree-of-Thought [80]). Then, they perform an exhaustive search within constrained spaces to identify the optimal combination that maximizes performance. Yet, they still rely on fixed workflows bound by developers’ experiences. Instead, drawing strengths from these arts, shifts the burden of workflow design from developers to LLM agents, enabling more flexible and adaptive edge AI development. Notably, can also be orthogonally integrated with these arts for further optimization.
Conclusion
is a self-exploring and self-evolving paradigm for adaptive edge AI development. By fully exploiting the reasoning abilities of LLMs, agents can autonomously explore distinct appropriate workflows for various edge AI tasks. In addition, our continuous LLM tuning paradigm progressively strengthens agents to tackle evolving edge AI knowledge and environments. Extensive evaluations demonstrate the effectiveness, generalizability, flexibility, and adaptability of in handling diverse and evolving edge AI tasks. Looking ahead, we envision as a stepping stone toward more autonomous agentic systems capable of adapting to dynamic environments as well as evolving through lifelong learning and reflection.
References
- [1]S. L. Siam, H. Ahn, L. Liu, S. Alam, H. Shen, Z. Cao, N. Shroff, B. Krishnamachari, M. Srivastava, and M. Zhang, “Artificial intelligence of things: A survey,” ACM TON, vol. 21, no. 1, pp. 1–75, 2025.DOI
- [2]Z. Wan, H. Shen, X. Wang, C. Liu, Z. Mai, and M. Zhang, “Meda: Dynamic key value allocator for efficient multimodal long-context inference,” arXiv preprint arXiv:2502.17599, 2025.
- [3]C. Gong, B. Liang, W. Gao, and C. Xu, “Data can speak for itself: Quality-guided utilization of wireless synthetic data,” arXiv preprint arXiv:2506.23174, 2025.arxiv.org/abs/2506.23174
- [4]X. Cheng, J. Zhang, D. Ning, N. Li, Y. Li, T. Wu, W. Xu, J. Zhang, and Q. Sun, “Integrated air and communications: A two-way catalysis toward 6g and beyond,” Journal of Communications and Information Networks, vol. 10, no. 3, pp. 191–200, 2025.DOI
- [5]C. Y. Lee, P. Yi, M. Fite, T. Rao, S. Achour, and Z. Kapetanovic, “Hypercam: Low-power onboard computer vision for iot cameras,” in ACM MobiCom, 2025, pp. 529–542.arxiv.org/abs/2501.10547
- [6]S. Liu, D. Wen, D. Li, Q. Chen, G. Zhu, and Y. Shi, “Energy-efficient optimal mode selection for edge AI inference via integrated sensing-communication-computation,” IEEE Trans. Mob. Comput., vol. 23, no. 12, pp. 14 248–14 262, 2024.
- [7]K. Cui, Q. Yang, L. Shen, Y. Zheng, F. Xiao, and J. Han, “Towards ice-empowered mmwave radars by capturing modulated vibrations,” IEEE Transactions on Mobile Computing, vol. 23, no. 12, pp. 13787–13803, 2024.DOI
- [8]Q. Shao, J. Chen, H. M. C. Leung, M. Zhao, R. Xu, J. Liu, L. M. D. García, X. Jiang, M.-P. St-Onge, and X. Zhou, “My pillow knows my sleep: Sleep monitoring with computational fabrics in the pillowcase,” ACM IMWUT, vol. 9, no. 3, pp. 1–26, 2025.DOI
- [9]Q. Shao, J. Liu, E. Bejerano, H. M. Colman, J. Nie, X. Jiang, and X. Zhou, “Joey: supporting kangaroo mother care with computational fabrics,” in ACM MobiSys, 2024, pp. 237–251.
- [10]P. Hu, Y. Qian, T. Zheng, A. Li, Z. Chen, Y. Gao, X. Cheng, and J. Luo, “A transformer-powered robust and efficient multimodal inference for autonomous driving,” IEEE TMC, 2024.arxiv.org/abs/2410.09747
- [11]T. Do, B. X. Nguyen, Q. D. Tran, E. Tjiptutra, T.-C. Chiu, and A. Nguyen, “Lightweight temporal transformer decomposition for federated autonomous driving,” arXiv preprint arXiv:2506.23523, 2025.
- [12]F. Ahmad, C. Shin, W. Pang, J. Cashman, B. Leong, and R. Govindan, “idriving: Toward safe and efficient infrastructure-directed autonomous driving,” CoRR, 2022.
- [13]J. Cui, C. Tang, J. Holtz, J. Nguyen, A. G. Allievi, H. Qiu, and P. Stone, “Towards natural language communication for cooperative autonomous driving via self-play,” arXiv preprint arXiv:2505.18334, 2025.DOI
- [14]Z. Zhang, S. Yue, and J. Zhang, “Towards resource-efficient edge AI: from federated learning to semi-supervised model personalization,” IEEE Trans. Mob. Comput., vol. 23, no. 5, pp. 6104–6115, 2024.DOI
- [15]K. Wang, Z. Zhou, and Z. Li, “Towards accurate training time estimation for on-device heterogeneous federated learning,” IEEE Trans. Mob. Comput., vol. 25, no. 1, pp. 1104–1121, 2026.DOI
- [16]F. Corti, B. Maag, J. Schauer, U. Pferschy, and O. Saukh, “REDS: resource-efficient deep subnetworks for dynamic resource constraints,” IEEE Trans. Mob. Comput., vol. 25, no. 1, pp. 451–465, 2026.arxiv.org/abs/2311.13349
- [17]C. Fang, B. Guo, S. Liu, Z. Zhou, J. Tang, K. Ma, S. Luo, G. Song, and Z. Yu, “Responsive test-time model adaptation for mobile applications via runtime-efficient sparse updates,” IEEE Trans. Mob. Comput., vol. 25, no. 9, pp. 14 448–14 466, 2026.DOI
- [18]L. Yi, H. Zhang, H. Yu, G. Wang, X. Liu, and Q. Hu, “pfedlora: Model-heterogeneous personalized federated learning with homogeneous low-rank adapter sharing on mobile edge devices,” IEEE Trans. Mob. Comput., vol. 25, no. 9, pp. 13 898–13 911, 2026.DOI
- [19]J. Cao, L. Han, K. Wang, Z. Xiao, and Z. Li, “Systematic pruning and acceleration for tinymI on extremely weak iot devices,” IEEE Transactions on Mobile Computing, vol. 25, no. 11, pp. 19 407–19 422, 2026.DOI
- [20]L. Shen, Q. Yang, K. Cui, Y. Zheng, X.-y. Wei, J. Liu, and J. Han, “Fedconv: A learning-on-model paradigm for heterogeneous federated clients,” in Proceedings of the 22st Annual International Conference on Mobile Systems, Applications and Services, 2024, pp. 1–14.
- [21]L. Shen, Q. Yang, Y. Zheng, and M. Li, “Autoioit: Llm-driven automated natural language programming for aiot applications,” in Proceedings of the 31st Annual International Conference on Mobile Computing and Networking, 2025, pp. 468–482.
- [22]H. Yang, M. Li, M. Han, Z. Li, and W. Xu, “Automebed: Llm-driven automated software development for generic embedded iot systems,” in Proceedings of the 2026 ACM/IEEE International Conference on Embedded Artificial Intelligence and Sensing Systems, 2026, pp. 362–376.DOI
- [23]L. Shen and Y. Zheng, “Iotcoder: A copilot for iot application development,” in Proceedings of the 30th Annual International Conference on Mobile Computing and Networking, 2024, pp. 1647–1649.DOI
- [24]Y. Shang, Y. Li, K. Zhao, L. Ma, J. Liu, F. Xu, and Y. Li, “Agentsquare: Automatic llm agent search in modular design space,” in International Conference on Learning Representations, vol. 2025, 2025, pp. 3841–3865.arxiv.org/abs/2410.06153
- [25]S. Hu, C. Lu, and J. Clune, “Automated design of agentic systems,” in International Conference on Learning Representations, vol. 2025, 2025, pp. 21 344–21 777.arxiv.org/abs/2408.08435
- [26]H. Moon and H. Lim, “Needlechain: Measuring intact long-context reasoning capability of large language models,” arXiv preprint arXiv:2507.22411, 2025.arxiv.org/abs/2507.22411
- [27]“Reinforcement fine-tuning,” 2024. [Online]. Available: https://platform.openai.com/docs/guides/reinforcement-fine-tuning
- [28]H. Wen, S. Tian, B. Pavlov, W. Du, Y. Li et al., “Autodroid-v2: Boosting slm-based gui agents via code generation,” in ACM MobiSys, 2025, pp. 223–235.arxiv.org/abs/2412.18116
- [29]S. Lee, J. Choi, J. Lee, M. H. Wasi, H. Choi, S. Ko, S. Oh, and I. Shin, “Mobilegpt: Augmenting llm with human-like app memory for mobile task automation,” in ACM MobiCom, 2024, pp. 1119–1133.DOI
- [30]Q. Nguyen, T. Le, H. Nguyen, T. Vo, T. D. Ta, B. Huang, M. N. Vu, and A. Nguyen, “Graspmas: Zero-shot language-driven grasp detection with multi-agent system,” arXiv preprint arXiv:2506.18448, 2025.arxiv.org/abs/2506.18448
- [31]Z. Wang, Y. Wang, Z. Wu, H. Ma, Z. Li, H. Qiu, and J. Li, “Cmp: Cooperative motion prediction with multi-agent communication,” IEEE RA-L, 2025.DOI
- [32]S. Zhang, H. Jia, S. Li, T. Dang, Y. Hu, X. Yi, and H. Li, “Position: Human-robot interaction in embodied intelligence demands a shift from static privacy controls to dynamic learning,” arXiv preprint arXiv:2509.19041, 2025.arxiv.org/abs/2509.19041
- [33]S. Lee, M. Kang, J. Lee, S. Lee, D. Kim, J. Hong, J. Shin, P. Zhang, and J. Ko, “Llm-based question-answer framework for sensor-driven hvac system interaction,” arXiv preprint arXiv:2507.04748, 2025.arxiv.org/abs/2507.04748
- [34]Q. Dong, X. Chen, and M. Satyanarayanan, “Creating edge ai from cloud-based llms,” in ACM HotMobile, 2024, pp. 8–13.DOI
- [35]R. Choi, T. Kim, S. Park, S. Yoo, J. G. Kim, and S.-J. Lee, “Collective voice: Recovered-peer support mediated by an llm-based chatbot for eating disorder recovery,” arXiv preprint arXiv:2509.15289, 2025.arxiv.org/abs/2509.15289
- [36]R. Choi, T. Kim, S. Park, J. G. Kim, and S.-J. Lee, “Private yet social: How llm chatbots support and challenge eating disorder recovery,” in ACM CHI, 2025, pp. 1–19.arxiv.org/abs/2412.11656
- [37]Z. Zhang, A. Metzger, Y. Mei, F. Hähnlein, Z. Englhardt, T. Cheng, G. D. Abowd, S. Patel, A. Schulz, and V. Iyer, “Towards autonomous sustainability assessment via multimodal ai agents,” arXiv preprint arXiv:2507.17012, 2025.
- [38]K. Gong, W. Dong, H. Wang, Y. Peng, and Y. Gao, “Programming embedded iot applications in natural language with iotpilot,” in Proceedings of the 23rd Annual International Conference on Mobile Systems, Applications and Services, 2025, pp. 70–82.DOI
- [39]F. Wang, Y. Lv, M. Zhu, H. Ding, and J. Han, “Xrf55: A radio frequency dataset for human indoor action analysis,” Proceedings of the ACM on Interactive, Mobile, Wearable and Ubiquitous Technologies, vol. 8, no. 1, pp. 1–34, 2024.DOI
- [40]T. Zheng, A. Li, Z. Chen, H. Wang, and J. Luo, “Autofed: Heterogeneity-aware federated multimodal learning for robust autonomous driving,” in Proceedings of the 29th annual international conference on mobile computing and networking, 2023, pp. 1–15.arxiv.org/abs/2302.08646
- [41]X. Ouyang, Z. Xie, H. Fu, S. Cheng, L. Pan, N. Ling, G. Xing, J. Zhou, and J. Huang, “Harmony: Heterogeneous multi-modal federated learning through disentangled model training,” in Proceedings of the 21st Annual International Conference on Mobile Systems, Applications and Services, 2023, pp. 530–543.DOI
- [42]M. Prabu, S. Sountharajan, E. Suganya, and D. P. Bavirisetti, “Contribution of python to improving efficiency in artificial intelligence and advancing automation capabilities,” in Smart Computing Techniques in Industrial IoT, 2024, pp. 201–218.DOI
- [43]X. Zhang, Z. Huang, E. O. Taga, C. Joe-Wong, S. Oymak, and J. Chen, “Efficient contextual llm cascades through budget-constrained policy learning,” Advances in Neural Information Processing Systems, vol. 37, pp. 91 691–91 722, 2024.arxiv.org/abs/2404.13082
- [44]S. I. Venieris, M. Almeida, R. Lee, and N. D. Lane, “NAWQ-SR: A hybrid-precision NPU engine for efficient on-device super-resolution,” IEEE Trans. Mob. Comput., vol. 23, no. 3, pp. 2367–2381, 2024.DOI
- [45]L. Zheng, W.-L. Chiang, Y. Sheng, S. Zhuang, Z. Wu, Y. Zhang, Z. Lin, Z. Li, D. Li, E. Xing et al., “Judging llm-as-a-judge with mt-bench and chatbot arena,” NeurIPS, vol. 36, pp. 46 595–46 623, 2023.arxiv.org/abs/2306.05685
- [46]S. Han, Q. Zhang, Y. Yao, W. Jin, and Z. Xu, “Llm multi-agent systems: Challenges and open problems,” arXiv preprint arXiv:2402.03578, 2024.arxiv.org/abs/2402.03578
- [47]L. L. Zhang, S. Han, J. Wei, N. Zheng, T. Cao, Y. Yang, and Y. Liu, “Nn-meter: Towards accurate latency prediction of deep-learning model inference on diverse edge devices,” in Proceedings of the 19th Annual International Conference on Mobile Systems, Applications and Services, 2021, pp. 81–93.DOI
- [48]X. Wang, J. Wei, D. Schuurmans, Q. Le, E. Chi, S. Narang, A. Chowdhery, and D. Zhou, “Self-consistency improves chain of thought reasoning in language models,” arXiv preprint arXiv:2203.11171, 2022.arxiv.org/abs/2203.11171
- [49]Y. Gao, Y. Xiong, X. Gao, K. Jia, J. Pan, Y. Bi, Y. Dai, J. Sun, H. Wang, and H. Wang, “Retrieval-augmented generation for large language models: A survey,” arXiv preprint arXiv:2312.10997, vol. 2, no. 1, 2023.arxiv.org/abs/2312.10997
- [50]L. Shen, Q. Yang, X. Huang, Z. Ma, and Y. Zheng, “Gpiot: Tailoring small language models for iot program synthesis and development,” in Proceedings of the 23rd ACM Conference on Embedded Networked Sensor Systems, 2025, pp. 199–212.arxiv.org/abs/2503.00686
- [51]Z. Zhang, P. Dash, Y. C. Hu, Q. Xu, J. Li, and H. Guan, “Dissecting the impact of mobile dvfs governors on llm inference performance and energy efficiency,” arXiv preprint arXiv:2507.02135, 2025.arxiv.org/abs/2507.02135
- [52]Y. Liu, Q. Xu, and Y. C. Hu, “Cronus: Efficient llm inference on heterogeneous gpu clusters via partially disaggregated prefill,” arXiv preprint arXiv:2509.17357, 2025.arxiv.org/abs/2509.17357
- [53]Z. Wan, Z. Dou, C. Liu, Y. Zhang, D. Cui, Q. Zhao, H. Shen, M. Zhang et al., “Srpo: Enhancing multimodal llm reasoning via reflection-aware reinforcement learning,” arXiv preprint arXiv:2506.01713, 2025.arxiv.org/abs/2506.01713
- [54]R. Yuan, R. M. Gower, and A. Lazaric, “A general sample complexity analysis of vanilla policy gradient,” in International Conference on Artificial Intelligence and Statistics. PMLR, 2022, pp. 3332–3380.
- [55]J. Schulman, P. Moritz, S. Levine, M. Jordan, and P. Abbeel, “High-dimensional continuous control using generalized advantage estimation,” arXiv preprint arXiv:1506.02438, 2015.arxiv.org/abs/1506.02438
- [56]V. Konda and J. Tsitsiklis, “Actor-critic algorithms,” Advances in neural information processing systems, vol. 12, 1999.
- [57]M. I. Azeem, F. Palomba, L. Shi, and Q. Wang, “Machine learning techniques for code smell detection: A systematic literature review and meta-analysis,” Information and Software Technology, vol. 108, pp. 115–138, 2019.DOI
- [58]“o4-mini,” 2024. [Online]. Available: https://platform.openai.com/docs/models/o4-mini
- [59]“Tavily,” 2022. [Online]. Available: https://github.com/tavily-ai/tavily-python
- [60]“Chroma,” 2022. [Online]. Available: https://github.com/chroma-core/chroma
- [61]“Pylint,” 2025. [Online]. Available: https://github.com/pylint-dev/pylint
- [62]X. Yue, Y. Ni, K. Zhang, T. Zheng, R. Liu, G. Zhang, S. Stevens, D. Jiang, W. Ren, Y. Sun et al., “MMMU: A massive multi-discipline multimodal understanding and reasoning benchmark for expert agi,” in Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, 2024, pp. 9556–9567.
- [63]T. Matuszka, I. Barton, Á. Butykai, P. Hajas, D. Kiss, D. Kovács, S. Kunsági-Máté, P. Lengyel, G. Németh, L. Pető et al., “aimotive dataset: A multimodal dataset for robust autonomous driving with long-range perception,” arXiv preprint arXiv:2211.09445, 2022.arxiv.org/abs/2211.09445
- [64]“Github copilot,” 2024. [Online]. Available: https://github.com/features/copilot
- [65]M. A. Islam, M. E. Ali, and M. R. Parvez, “Mapcoder: Multi-agent code generation for competitive problem solving,” in Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics, 2024, pp. 4912–4944.arxiv.org/abs/2405.11403
- [66]D. Huang, J. M. Zhang, M. Luck, Q. Bu, Y. Qing, and H. Cui, “Agentcoder: Multi-agent-based code generation with iterative testing and optimisation,” arXiv preprint arXiv:2312.13010, 2023.arxiv.org/abs/2312.13010
- [67]Y. Wang, H. Le, A. Gotmare, N. Bui, J. Li, and S. Hoi, “CodeT5+: Open code large language models for code understanding and generation,” in Proceedings of the 2023 conference on empirical methods in natural language processing, 2023, pp. 1069–1088.
- [68]M. Chen, J. Tworek, H. Jun, Q. Yuan, H. P. D. O. Pinto, J. Kaplan, H. Edwards, Y. Burda, N. Joseph, G. Brockman et al., “Evaluating large language models trained on code,” arXiv preprint arXiv:2107.03374, 2021.arxiv.org/abs/2107.03374
- [69]S. Butterworth et al., “On the theory of filter amplifiers,” Wireless Engineer, vol. 7, no. 6, pp. 536–541, 1930.
- [70]A. Li, J. Sun, P. Li, Y. P. Hu, H. Li, and Y. Chen, “Hermes: an efficient federated learning framework for heterogeneous mobile clients,” in ACM MobiCom, 2021, pp. 420–437.DOI
- [71]“Open neural network exchange,” 2021. [Online]. Available: https://onnx.ai/
- [72]“TensorRT,” 2024. [Online]. Available: https://github.com/NVIDIA/TensorRT
- [73]“psutil,” 2025. [Online]. Available: https://github.com/giampaolo/psutil
- [74]N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. Yao, “Reflexion: Language agents with verbal reinforcement learning,” Advances in neural information processing systems, vol. 36, pp. 8634–8652, 2023.arxiv.org/abs/2303.11366
- [75]S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao, “ReAct: Synergizing reasoning and acting in language models,” in International Conference on Learning Representations (ICLR), 2023.arxiv.org/abs/2210.03629
- [76]A. Sarkar and I. Drosos, “Vibe coding: programming through conversation with artificial intelligence,” arXiv preprint arXiv:2506.23253, 2025.arxiv.org/abs/2506.23253
- [77]H. Xu, L. Han, Q. Yang, M. Li, and M. Srivastava, “Penetrative ai: Making llms comprehend the physical world,” in ACM HOTMOBILE, 2024, pp. 1–7.
- [78]J. Zhang, J. Xiang, Z. Yu, F. Teng, X. Chen, J. Chen, M. Zhuge, X. Cheng, S. Hong, J. Wang et al., “Aflow: Automating agentic workflow generation,” in International Conference on Learning Representations, vol. 2025, 2025, pp. 34040–34077.arxiv.org/abs/2410.10762
- [79]J. Wei, X. Wang, D. Schuurmans, M. Bosma, F. Xia, E. Chi, Q. V. Le, D. Zhou et al., “Chain-of-thought prompting elicits reasoning in large language models,” Advances in neural information processing systems, vol. 35, pp. 24 824–24 837, 2022.arxiv.org/abs/2201.11903
- [80]S. Yao, D. Yu, J. Zhao, I. Shafran, T. Griffiths, Y. Cao, and K. Narasimhan, “Tree of thoughts: Deliberate problem solving with large language models,” Advances in neural information processing systems, vol. 36, pp. 11 809–11 822, 2023.arxiv.org/abs/2305.10601



