ECCV2026 LLM Agent Image Generation symbolic concept learning agentic workflow generation continual learning verbalized backpropagation compositional image editing

SymbOmni: Evolving Agentic Omni Models via Symbolic Concept Learning¶

Conference: ECCV2026
Paper: ECCV 2026 official page / Project page
Full-text Cache: ../paper_cache/ECCV2026/eccv-5873.txt
Area: LLM Agent / Image Generation
Keywords: symbolic concept learning, agentic workflow generation, continual learning, verbalized backpropagation, compositional image editing

TL;DR¶

SymbOmni does not generate end-to-end; it builds a memory-bearing agent on top of ComfyUI that abstracts every successful or failed attempt into a "symbolic concept" (a parameterized, executable workflow template) stored in an optimizable Symbolic Concept Box, retrieves and composes those concepts through an induction–transduction cycle, and refines the box with verbalized backpropagation — never updating a single model parameter — reaching 86.0% total resolve rate on ComfyBench (up from 73.0%), 0.98 on GenEval, and cutting total token consumption by 33.9%.

Background & Motivation¶

Visual generation is now pervasive across text-to-image, text-to-video and interactive creation, yet the dominant recipe is still a monolithic model. On the open-source side, unified generation-understanding models produce unstable quality and lack structured planning; on the closed-source side, GPT-Image-1 and Nano Banana are strong but sealed, locking down architectural flexibility, downstream scalability and multimodal adaptation. The more fundamental bottleneck is not single-shot generation quality but the absence of cumulative learning: tasks are treated in isolation, so what worked last time is never distilled into a reusable component, and the next similar request is again solved by from-scratch reasoning inside a fixed parametric memory. The authors name this the perpetual novice problem — poor compositional generalization, inefficient knowledge retention, redundant reasoning and brittle decision-making. Existing remedies each fall short: prompt- or tool-calling-based agents produce unstable, non-reusable reasoning chains; implicit learning and workflow frameworks are either hard to scale or too rigid for dynamic demands; and in enterprise settings with highly personalized workflows, long-context methods that stuff history into the prompt incur prohibitive compute and raise hallucination risk.

The real tension is that long-term adaptation requires an agent to abstract experience into structured, composable knowledge components, while the prevailing unified generation paradigm lacks exactly that layer. Knowledge lives only in the weights, so changing it means changing parameters — expensive, vulnerable to catastrophic forgetting, and unable to explain what the system actually learned. Experience therefore cannot settle into a library that can be retrieved, composed, individually evaluated or rolled back.

This paper's angle is to add an explicit symbolic knowledge layer outside the parameters: a Symbolic Concept Box serving as optimizable long-term memory, holding problem-solving strategies encoded as parameterized workflow templates. The system runs as a closed loop of induction (abstracting experience into concepts) and transduction (composing concepts into a solution), and uses verbalized backpropagation — natural-language feedback — to add, edit and remove memory entries instead of performing gradient updates; tasks such as text-to-image, image editing and video generation are unified on ComfyUI, so "omni" comes from the composability of the symbolic layer rather than from a shared weight space. Core idea: move visual generation's problem-solving ability out of the implicit knowledge in the weights and into a readable, writable, composable, scoreable library of symbolic concepts, and let an induction–transduction cycle with verbalized backpropagation make the agent a little stronger after every task — without touching a single parameter.

Method¶

Overall Architecture¶

The substrate of SymbOmni is ComfyUI: a workflow is a directed acyclic graph of nodes (each encapsulating a discrete operation such as model loading, latent sampling or post-processing) that serializes into JSON, giving fine-grained control over generated content at the cost of requiring expertise in node selection, parameter configuration and wiring. SymbOmni automates precisely that. Its input is a natural-language instruction (optionally with a reference image or video); its output is an actually executed image or video; its intermediate artifacts are an executable workflow JSON and a full execution trajectory. The system never touches the parameters of the generative models — it translates an instruction into a composition of concepts, hands it to ComfyUI, asks an Evaluation Agent to judge success, and commits the trajectory back into the concept library so that the next task starts from a better position.

The whole system runs on an "Induction–Memory–Transduction–Experience" loop with four phases. Transduction is problem solving: decompose the new instruction into semantic subtasks, perform hierarchical retrieval over the concept library, and let an LLM planner instantiate the retrieved concepts into an executable workflow. Execution runs the workflow step by step and records the full trajectory (instruction, workflow, output, concepts used, execution log). Induction is learning: the Evaluation Agent first makes a binary judgment on the output against the instruction; on success the trajectory is abstracted into symbolic experience that expands the library, while on failure a verbalized-backpropagation process diagnoses the cause, locates which concept to fix, and replays the correction. Memory Optimization consolidates the round's conclusions into the library as successful experience, negative experience, or parameter corrections. The four steps form a positive feedback loop: induction enriches memory, and memory makes the next transduction more accurate.

Concept-library initialization matters for the experiments: the workflow pool contains high-quality workflows and deliberately retains several suboptimal ones, so that the system's ability to discriminate good from bad during evolution can actually be tested — a precondition for the concept scores to be meaningful in retrieval ranking.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400, 'subGraphTitleMargin': {'top': 8, 'bottom': 16}}}}%%
flowchart TD
    A["User instruction<br/>text / reference image / video"] --> B["Symbolic Concept Box<br/>Desc + SWI + Params + Score"]
    B --> C["Hierarchical retrieval & instantiation<br/>decompose → recall → filter → rank → bind"]
    C -->|"generate and execute workflow"| E{"Evaluation Agent judgment"}
    subgraph D3["Dual-feedback induction & verbalized backpropagation"]
        direction TB
        F["Success: symbolic abstraction<br/>synthesize new / reinforce existing"]
        G["Failure: dual-verifier localization<br/>syntax + semantics → symbolic gradient → replay"]
    end
    E -->|"success"| F
    E -->|"failure"| G
    F --> H["Concept-box memory consolidation<br/>success / negative / parameter refinement"]
    G --> H
    H -->|"next task retrieves from the box"| C

Key Designs¶

1. Symbolic concepts and the Concept Box: solidifying reusable experience into parameterized workflow templates

Before experience can be reused, it must be representable. SymbOmni defines each symbolic concept as a quadruple:

\[C_k = (Desc_k,\ SWI_k,\ Params_k,\ Score_k)\]

Here \(Desc_k\) is a natural-language description of the concept's purpose (later used for similarity computation); \(SWI_k\) (Symbolic Workflow Instruction) is a parameterized workflow template describing a sequence of operations; \(Params_k\) holds the best parameter configuration accumulated from prior uses; and \(Score_k\) dynamically records how effective the concept has historically been. At execution time the template's parameter slots are filled from \(Params_k\) and it can run directly. A symbolic concept is therefore neither a vector nor free-form text but an executable program template plus a semantic description, tuned parameters and a utility score: retrieval uses the description, execution uses the template and parameters, ranking uses the score — three roles sharing one representation.

The Concept Box is the set of all such concepts, formalized as a language system \(L=(\Sigma, R)\): \(\Sigma=\{Desc_k\}\) is a vocabulary of semantic primitives and \(R=\{SWI_k\}\) is a set of production rules specifying which workflow compositions are valid. The immediate consequence is that planning stops being derivation from scratch and becomes a grammatical derivation in \(L\) — assembling previously validated building blocks. This is also the key departure from tool-calling agents: a tool is an opaque call, whereas a concept carries both semantics and structure, so it can be retrieved, composed, diagnosed and surgically edited.

2. Hierarchical retrieval and instantiation: turning planning into on-demand composition over the concept library

Given a new instruction \(I_{new}\), asking an LLM to "come up with a workflow" is the failure mode this paper wants to avoid (long, unstable, non-reusable reasoning chains). SymbOmni first decomposes the instruction into subtasks, then performs a two-level retrieval, and only then generates the workflow. The retrieval can be written as a composite operator:

\[C_{ret} = Rank \circ Filter_{struct} \circ Retrieve_{sem}(ST, CB)\]

\(Retrieve_{sem}\) recalls candidates by cosine similarity between description embeddings, \(\cos(\text{Embed}(Desc_k), \text{Embed}(ST_m))\), answering "have I seen something like this before"; \(Filter_{struct}\) enforces the dependency constraints among subtasks and drops structurally unusable candidates (for instance a concept whose prerequisites are missing); \(Rank\) then sorts survivors by \(Score_k\) so that historically effective concepts come first. The LLM planner next produces candidate workflows \(WF_{cand}\) conditioned on the retrieved concepts and the grammar \(G\), and \(Instantiate\) binds \(Params_k\) into the empty slots of the corresponding \(SWI_k\) templates, yielding an executable workflow JSON. The value of this design is not just "retrieval augmentation": splitting semantic recall, structural constraints and utility ranking into three levels separates two distinct error modes — picking the wrong tool versus picking the right tools in the wrong order — the former handled by description similarity, the latter by dependency constraints, and later failure diagnosis can point at exactly which level went wrong.

3. Dual-feedback induction and verbalized backpropagation: distilling both success and failure into symbolic knowledge

All learning happens after inference and relies on no gradients. After each execution round, the Evaluation Agent compares the output \(O\) with the instruction \(I_{new}\) and emits a binary judgment \(Judge\in\{\text{True},\text{False}\}\), which splits the pipeline in two. On success, the trajectory \(\tau=(I_{new}, WF_{cand}, O, C_{ret}, ExecutionLog)\) undergoes symbolic abstraction: the generalizable part is extracted from this particular use, either by synthesizing a new composite concept (freezing a multi-step combination that was assembled on the fly but proved effective) or by reinforcing an existing concept (updating its \(Params_k\) and \(Score_k\)).

On failure, the system enters a diagnosis process inspired by verbalized backpropagation: two complementary verifiers inspect the trajectory — \(Error_{hard}\) checks syntactic and procedural correctness (whether the workflow compiles, whether node parameters and connections are valid) and \(Feedback_{soft}\) evaluates semantic quality (style, preserved detail, whether every requirement in the instruction was met). An LLM then turns these two signals into a structured "linguistic loss":

\[L_{lang} = LLM\big(P_{loss}(\tau,\ Error_{hard},\ Feedback_{soft})\big)\]

Chain attribution then converts it into a "symbolic gradient" \(\nabla_{sym}\) — which entry of the concept library, and which parameter, should change — and the system replays the revision to verify it before updating the library. This works because failure signals are split into structural errors and semantic shortfalls: the former can be localized to a specific node or connection, the latter to a concept choice or parameter, and conflating the two is precisely why prior agents retry and drift instead of converging. The paper depicts this mechanism in its figures as a dual-verification loop of a syntax compiler plus a VLM verifier (⚠️ the original describes this loop only briefly; refer to the paper and its supplementary material for implementation detail).

4. Concept-box memory consolidation: success, negative and parameter-refinement updates

Learning must record not only what works but also what does not. Memory updates are explicitly partitioned into three kinds: successful trajectories are abstracted into reusable success concepts \(C_{success}\); failed trajectories yield negative concepts \(C_{negative}\) that help avoid repeating the same mistake; and a refinement entry \(C_{refine}\) may update parameters only, when the concept itself is still valid but a setting needs adjustment. Together with the dynamic update of \(Score_k\), these three kinds complete one self-evolution round, and the next planning step is affected by all of them when deciding which concepts to select and how to rank them. Negative knowledge and parameter refinement are typically missing from "memory of successful trajectories" approaches — but they are also what the paper covers most thinly: the update rule for \(Score_k\), how negative concepts participate in retrieval scoring, and how composite concepts are deduplicated against new ones are all left open (⚠️ refer to the original paper). As for the relation between library size and performance, the paper offers only indirect evidence (accumulate online then reuse offline, plus transfer from an external library) and never reports a "number of concepts vs. solve rate" curve, so whether library growth or concept conflicts slow the system down in long runs remains unknown.

A Worked Example¶

Figure 3 of the paper walks one "vintage photo to anime-styled video" instruction through the entire pipeline. The user supplies a vintage-style reference photo and asks for an anime-styled video, adding a prompt: a quiet residential street, 5 seconds, 25 FPS. Planning decomposes the instruction into subtasks, semantically recalls concepts such as denoise/restore, style transfer, keyframe generation and frame interpolation, ranks them by utility, and the LLM lays out Plan 1 (denoise and restore) → Plan 2 (anime stylization) → Plan 3 (keyframe generation plus interpolation). After instantiation into workflow JSON, execution follows Step 1 parse the plan, Step 2 load models, Step 3 run image-to-video, Step 4 self-refine on ComfyUI, producing a video labelled 6 s at 25 FPS (the instruction says 5 seconds, ⚠️ the caption's duration label and the instruction disagree — refer to the original paper).

Evaluation yields two real feedback samples on the success side: one experience recorded as "Restore photo → then style transfer, higher quality" and another as "Keyframes → then interpolation, faster with quality" — exactly the "synthesize a new composite concept" path of Design 3, freezing the effective combinations "restore then stylize" and "keyframes then interpolate". A failure-side sample reads "workflow 028 applied an oil painting style transformation to the initial image, but it can hardly preserve details"; such diagnostically specific negative entries enter the memory so that future planning avoids the same route. Throughout, no model parameter is ever updated — only the concept library becomes better.

Loss & Training¶

SymbOmni has no training in the gradient-descent sense: the only loss is the linguistic \(L_{lang}\), and the only optimizer is the set of add/edit/delete operations on the concept library. One full update is captured by two rules: successful trajectories follow \(CB \leftarrow CB \cup Symbolize(\tau, \text{Positive})\) (add or reinforce a concept), failed trajectories follow \(CB \leftarrow Refine(CB,\ Replay(\tau, \nabla_{sym}))\) (localize, correct, replay-verify). This is precisely why the paper calls it continual self-improvement without parameter fine-tuning — the learning artifact is an external, readable and writable knowledge base rather than a change in weights.

Implementation-wise, all experiments run inside the ComfyUI framework with Gemini 2.5 Flash as the reasoning engine; for fair comparison across agentic systems, the maximum search depth is fixed at 10 and the maximum number of retries at 4. The system also has online and offline modes: online, the agent may access external workflow-description documents; offline, it is allowed to use only the accumulated symbolic concepts and sees no documentation — a setting used in the experiments to test whether the concept library can substitute for documentation.

Key Experimental Results¶

Three public benchmarks: ComfyBench (200 tasks — 100 vanilla, 60 complex, 40 creative — for workflow construction), GenEval (semantic consistency and visual fidelity in text-to-image), and ReasonEdit (multi-step reasoning-based image editing); the supplementary material adds GenEval2 and Kris Bench. Four evaluation dimensions: Pass Rate (proportion of generated workflows that execute successfully with the correct structure), Resolve Rate (proportion of final outputs that satisfy the instruction's semantic requirements), Generation Quality, and Token Consumption (average tokens per task).

Main Results¶

ComfyBench (autonomous workflow construction, %):

Method	Vanilla Pass	Vanilla Resolve	Complex Resolve	Creative Resolve	Total Resolve
GPT-4o + Few-shot	32.0	27.0	8.3	0.0	16.0
GPT-4o + CoT	44.0	29.0	8.3	0.0	17.0
o1-preview + RAG	70.0	46.0	23.3	12.5	32.5
ComfyAgent	67.0	46.0	21.7	15.0	32.5
ComfyMind (reproduced)	100.0	84.0	75.0	42.5	73.0
SymbOmni	100.0	95.0	83.3	67.5	86.0
ComfyMind + Nano Banana	100.0	97.0	80.0	57.5	84.0
SymbOmni + Nano Banana	100.0	99.0	88.3	75.0	91.0

GenEval (text-to-image, overall and per subcategory):

Method	Overall	Single Obj.	Two Obj.	Counting	Colors	Position	Attr. Binding
SD3-Medium	0.74	0.99	0.94	0.72	0.89	0.33	0.60
Janus-Pro-7B	0.80	0.99	0.89	0.59	0.90	0.79	0.66
BAGEL	0.78	0.98	0.94	0.76	0.91	0.69	0.70
GPT-Image-1	0.84	0.99	0.92	0.85	0.92	0.75	0.61
ComfyMind (reproduced)	0.90	1.00	1.00	0.96	0.97	0.63	0.81
SymbOmni	0.98	1.00	1.00	0.99	0.98	0.97	0.95

On ReasonEdit (Figure 5; numbers taken from the prose): SymbOmni scores 9.190 overall versus ComfyMind's 8.135, with the largest gaps on spatial-reasoning subtasks (1.980 higher than ComfyMind on Mirror, 1.229 higher on Multiple-Objects). On the Mirror subcategory it reaches 8.983, which is 7.2% above Nano Banana (8.383) and 28.3% above ComfyMind (7.000); on Add-supp it obtains a perfect 10.000. It trails Nano Banana slightly on Left-Right and Color, which the authors attribute to the underlying generative model rather than to planning.

A user study further validates perceptual quality: 38 cases were evaluated pairwise and blindly, SymbOmni against each of four other methods, giving 152 comparison questions answered by 63 participants with 1,197 preference judgments (dimensions: semantic consistency, visual quality, compositional accuracy, overall preference). Overall preference rates: 59.2% against Nano Banana, 65.9% against ComfyMind, 68.4% against GPT-Image-1 and 73.9% against BAGEL — a win in every pairing.

Ablation Study¶

Removing the experience-retrieval module (w/o EXP), cost statistics on ReasonEdit:

Config	Input tokens↓	Output tokens↓	Total tokens↓	Requests per case↓
Ours (w/o EXP)	18,556.1	3,171.0	21,727.1	9.85
Ours (full)	12,463.4 (↓32.8%)	1,898.0 (↓40.1%)	14,361.4 (↓33.9%)	7.25 (↓26.4%)

Offline mode (only accumulated concepts, no documentation; Complex split, N = 30):

Method	Resolved↑	Avg Tries↓	Avg Tries (Resolved)↓
ComfyMind (with full description)	66.7%	2.000	1.600
SymbOmni (offline)	70.0%	1.433 (↓0.567)	1.190 (↓0.410)

Out-of-domain generalization (external concept library built from 147 in-the-wild workflows, then evaluated back on ComfyBench):

Method	Vanilla Pass	Vanilla Resolve	Complex Resolve	Creative Resolve	Overall
ComfyMind	100.0%	84.0%	55.0%	42.5%	67.0%
SymbOmni	100.0%	89.0%	66.7%	52.5%	75.0%
Improvement	+0.0	+5.0	+11.7	+10.0	+8.0

Key Findings¶

The harder the task, the larger the payoff from symbolic concepts. Relative gains grow from +5.0 points on vanilla (95.0 vs. 84.0) to +11.1% relative on complex and +58.8% relative on creative (42.5 → 67.5). Concept reuse mainly compensates for long-horizon composition and planning rather than single-step generation quality — easy tasks are already saturated, since Pass Rate hits 100% for both ComfyMind and SymbOmni.
The gains come from the mechanism, not the base model. With the same Nano Banana as the underlying generator, SymbOmni still leads ComfyMind 91.0% to 84.0% overall and 75.0% to 57.5% on creative, ruling out "better tools" as the explanation.
The memory module buys fewer failed attempts, not longer thinking. Removing experience retrieval inflates output tokens per case by 40.1% and requests by 26.4%, with total tokens up 33.9%. Note that although the prose claims all metrics degrade without memory retrieval, the table reports cost columns only; the accuracy deltas appear to live in the supplementary material (⚠️ refer to the original paper/supplement). The abstract's "over 40% token reduction" in fact refers to output tokens (40.1%); the total-token reduction is 33.9%.
A symbolic concept library can functionally replace documentation. In offline mode, with no access to workflow descriptions at all, it still resolves 70.0% of the Complex split — above ComfyMind's 66.7% with full documentation — while using 28.4% fewer average tries (25.6% fewer on solved tasks). This is the most practically valuable conclusion of the paper: experiential memory does not merely help, it can substitute for part of the external knowledge supply.
Evidence on library size versus performance is only indirect. Two experiments hint that accumulation helps: online grouping with later offline reuse (10 groups of 20 tasks, even indices online and odd indices offline, with experiences committed only after every task in a group finishes to prevent leakage), and transfer from a 147-workflow external concept library to ComfyBench. But no "number of concepts vs. solve rate" curve and no final library size are reported, so the long-run cost of growth, redundancy and conflicts stays unknown.
The base model sets the ceiling. On subcategories that depend on raw generative capability rather than planning (Left-Right, Color), SymbOmni is slightly behind Nano Banana, while Add-supp — which requires composing several operations correctly — earns a perfect score. The authors concede that an agentic system is inherently constrained by the quality of its constituent tools.
Cross-table comparisons need care. In Table 5, ComfyMind's Complex score is 55.0% and Overall 67.0%, whereas Table 1 reports 75.0% and 73.0% for the same reproduced method; the two experiments clearly use different subsets/protocols, so Table 5's absolute numbers must not be compared directly against Table 1.

Highlights & Insights¶

Experience is designed as a structure that is simultaneously retrievable, executable and scoreable. A concept = semantic description + parameterized workflow template + tuned parameters + utility score; retrieval uses the description via cosine recall, execution fills parameters into the template, ranking uses the score — one representation serving three roles, avoiding the usual split where "memory is a pile of text and execution is separate logic." This representation transfers directly to any "skill library + execution feedback" agent: code repair, robot skill libraries, data-analysis pipelines.
Verbalized backpropagation provides localization, not just reflection. A failed trajectory is split into hard syntactic/procedural errors and soft semantic feedback, turned into a structured linguistic loss, then converted by chain attribution into a "symbolic gradient" naming the concept or parameter to change, with replay verifying the fix. Compared with "reflect and retry," explainability is built into the learning loop rather than added afterward.
Negative concepts and parameter refinement make memory more than a success log. Entries are partitioned into \(C_{success}\) / \(C_{negative}\) / \(C_{refine}\), effectively giving the agent a list of pitfalls and a record of parameter tweaks — something a pure success-trajectory memory cannot provide (⚠️ the paper reports no separate ablation isolating the benefit of negative concepts).
The offline evaluation protocol is itself reusable methodology. Committing experience only after all tasks in a group are done, combined with stratified grouping, within-group similarity and shuffled group order, resolves the easily overlooked but high-impact question of when experience counts as visible in continual-learning evaluation.
The path to "omni" is worth noting. Omni here is not achieved by cramming modalities into one weight space; a single symbolic concept layer is reused and recomposed across text-to-image, image editing and video generation (keyframes plus interpolation). Cross-modal ability comes from composability of concepts, offering empirical support for a "lightweight model plus strong planning layer" route.

Limitations & Future Work¶

The judge is binary and therefore coarse. The Evaluation Agent outputs only \(Judge\in\{\text{True},\text{False}\}\), so a trajectory that satisfies half the requirements is marked as a failure and triggers replay-based refinement, potentially polluting the concept library; no judge accuracy or human agreement is reported. Replacing it with a calibrated continuous quality score (or a trained verifier) should be the first priority.
No size control or conflict resolution for the library. The update rule for \(Score_k\), how negative concepts affect retrieval ranking, and how composite concepts are deduplicated are all left open; growth, redundancy and mutually contradictory positive/negative concepts are real long-run concerns. Borrowing from version control — merging, versioning and rolling back concepts — would be a natural fix.
All experiments are locked to ComfyUI plus Gemini 2.5 Flash. Whether induction quality and retrieval still hold with a different reasoning engine or tool set is untested, and that is precisely where the claimed generality needs evidence.
Key evidence sits in the supplement. GenEval2, Kris Bench, cross-modal generalization, user-study details and the accuracy columns of the ablation are all supplementary, leaving outside readers unable to judge the memory module's true accuracy contribution from the main text.
Dependence on tool quality is admitted but not quantified. The subcategories where SymbOmni trails Nano Banana show that no amount of planning rescues a weak generator; a two-dimensional "tool quality × concept-library quality" analysis would make the claims much more convincing.
Improvement directions. Make \(Score_k\) an explicit utility estimate (bandit or Bayesian posterior) rather than an opaque "dynamic update"; add a usage-versus-benefit retirement rule for concepts; and treat the concept library as a portable asset to test sharing across base models and agents.

vs ComfyMind: it plans with tree search plus reactive feedback, depends on large-scale workflow documentation, and does not accumulate experience; SymbOmni replaces the documentation dependency with an optimizable symbolic memory, beating its 66.7% with 70.0% in the fully documentation-free offline setting and cutting average tries by 28.4%. The essential difference is "search again every time" versus "keep what the search found."
vs ComfyAgent / ComfyGPT: they also generate node-level workflows in ComfyUI, but domain coverage is limited and errors cascade; SymbOmni keeps failures local through "concept-template composition plus hard/soft dual-verifier localization" instead of letting one failure contaminate the whole chain.
vs Reflexion / TextGrad / Verbalized ML: these also use natural language as a backpropagation signal, but the feedback usually corrects only the current trajectory and is then discarded; the key difference is that SymbOmni applies linguistic feedback to a reusable, retrievable, utility-scored concept library, turning a one-off lesson into a long-term asset.
vs unified multimodal models such as GPT-Image-1 / BAGEL / Janus-Pro: they acquire knowledge through static parametric updates in weight space, so changing knowledge means changing parameters and the result is uninterpretable; SymbOmni keeps knowledge in an explicit symbolic layer where changing knowledge means changing memory, making it naturally cumulative and auditable — at the cost of longer reasoning chains and a ceiling set by tool quality.
vs AutoGPT / ReAct / Deep Research: all support iterative refinement but lack reliable error diagnosis and recovery, so failures typically lead to retries; SymbOmni's dual verifiers plus chain attribution specify which class of error occurred and which entry should change.

Rating¶

Novelty: ⭐⭐⭐⭐ The combination of a symbolic concept library, an induction–transduction cycle and verbalized backpropagation is new, and it relocates continual learning from weights to a readable/writable memory layer; each component, however, echoes prior work such as Reflexion, TextGrad or ComfyMind.
Experimental Thoroughness: ⭐⭐⭐⭐ Three benchmarks plus an offline protocol, out-of-domain generalization and a 63-participant user study give good coverage; points off because the key accuracy ablation, GenEval2/Kris Bench and cross-modal results are supplementary, and there is no concept-count-versus-performance curve.
Writing Quality: ⭐⭐⭐ The method is clearly explained, but Figures 3 and 4 are too information-dense to read, and the abstract-versus-text mismatch on "40% token reduction" plus the differing benchmark protocols between Tables 1 and 5 can mislead.
Value: ⭐⭐⭐⭐ It offers a deployable route to continuous improvement without parameter updates; the one-third token reduction and the finding that memory can replace documentation are directly attractive for enterprise personalized generation, and the concept representation transfers to other agent memory systems.