Towards Humanoid Robot Autonomy: A Dynamic Architecture Integrating Continuous thought Machines (CTM) and Model Context Protocol (MCP)

Libo Wang

REVIEW 4 major objections 4 minor 21 references

Towards Humanoid Robot Autonomy: A Dynamic Architecture Integrating Continuous thought Machines (CTM) and Model Context Protocol (MCP)

T0 review · 4 major / 4 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A dynamic architecture that couples continuous thought machines with a model context protocol can give humanoid robots a closed loop from scene perception to semantic thinking to generated action, and the paper reports simulation evidence…

desk verdict A genuinely interesting architectural idea—CTM as a thinking layer for MCP tool use—but the evaluation is an LLM role-play session, not a robot simulation, so the feasibility claim is unsupported. read the letter →

arxiv 2505.19339 v1 pith:G64QLV5H submitted 2025-05-25 cs.RO cs.AI

Libo Wang This is my paper

classification cs.ROcs.AI

keywords humanoidrobotautonomycontinuousthoughtmachinesmodelcontextprotocoltick-slabparallelizationrankcompressionautonomouscodingsimulation-basedevaluationtasksuccessrate

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper sets out to show that humanoid robots can escape two limitations: pre-scripted "thinking-planning-action" control that freezes in unfamiliar scenes, and tool-calling pipelines that mechanically "call tool, return result" without genuine reasoning. It proposes a dynamic architecture that couples a continuous thought machine, a recurrent neural design that evolves internal thought states over tick-like time steps, with the model context protocol, a standard interface for invoking external tools. The author argues that this coupling produces a closed loop in which scene perception drives semantic thinking, semantic thinking generates code and plans, and the plans are translated into torque-limited actuator commands. To support the claim, the paper reports nine simulated trials on an expanded language-grounded robot-task set, comparing its architecture with an open-source robot control baseline across seven metrics. The reported results, if accepted, would mean humanoid robots could generate their own actions from perceived situations rather than relying on engineer-written static rules.

What carries the argument

The load-bearing mechanism is the tick-slab CTM runtime. Each slab packs multiple tick-level internal updates, so a single input step can unfold into several rounds of thought, and multiple slabs can be expanded in parallel; the consensus aggregator then picks the most confident branch. Low-rank μ-MLP layers and a rank-one synchrony updater compress memory updates and preserve temporal coherence, which the paper says prevents parameter explosion without giving up reasoning depth. The MCP envelope router is the second hinge: it serializes the reasoned state, gates on confidence to decide whether to continue thinking or act, and uses a cached synchronization vector as a timeout fallback so the system never stalls. Together these modules are what the paper claims convert perception into autonomous, dynamically generated action rather than fixed tool calls.

What would settle it

Run the full architecture on a physical humanoid or a standard physics simulator with externally measured task completion, an independent scorer, and real-time deadlines. If the architecture's success rate no longer exceeds the rigid baseline, or if the same chat-session protocol gives materially different scores when an external observer does the scoring, the paper's central claim is falsified.

Watch

Extended reading notes

Core claim

The central claim is that the CTM-MCP architecture is feasible and effective for humanoid robot autonomy. The paper asserts that the architecture "breaks through the logical bottleneck of existing models" by giving robots a closed-loop ability to drive internal semantic thinking with scene perception and extend that thinking into timely action planning and dynamic operation. Concretely, the tick-slab runtime replaces serial reasoning with parallel candidate branches, the consensus aggregator merges the most confident branch into one synchronization tensor, the emotional-state loop modulates uncertainty thresholds, the MCP envelope router packages the decision into structured tool calls or sends it back for another thinking round, and the actuator controller maps the result onto smooth, constrained joint trajectories. Across nine epochs, the architecture reports higher maximum values and lower variance than the baseline on task success, execution success, cognitive representation, self-assessment, and effectiveness metrics. The author reads this as evidence that the architecture solves both the static-planning gap and the rigid tool-calling gap.

Load-bearing premise

The conclusion depends on treating a cloud chat session, in which the same model runs the architecture code and turns its own execution results into metric values, as a faithful simulation of humanoid robot control; if that equivalence fails, the reported feasibility and effectiveness do not transfer to real robots.

Editorial extensions

If this is right

If the architecture is correct, a humanoid robot can accept a novel task description, deliberate over its perception in internal time, and write its own action sequence instead of matching a pre-programmed behavior.
Because the router falls back to a cached decision on timeout, the system has a bounded-time guarantee: it will emit an action even when reasoning is slow or a branch stalls.
Rank compression and shared low-rank updates mean increased reasoning depth does not require large parameter stacks, making the approach a candidate for embedded deployment.
The higher and steadier scores across the seven metrics imply the architecture can serve as a reference for dynamic autonomous coding in humanoid control research.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The paper's experimental setting, a cloud chat session where the same model runs the code and converts results into scores, leaves open whether the advantage survives on physical hardware; a fair test would use third-party logging and external timing.
The tick-slab and timeout-fallback design may generalize to any real-time agent, not just humanoids, because it offers a reasoning loop with a hard deadline and a cached output.
A sharper test would deliberately vary task novelty: if the success-rate advantage grows as tasks move further from the training distribution, the autonomous-coding claim is strengthened; if it shrinks, the architecture may be reweighting known routines rather than generating genuinely new code.
Local CPU or GPU execution would let the millisecond-level adaptive-computation advantage of continuous thought be measured directly, since cloud chat latency and quotas can mask it.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

The paper proposes coupling Continuous Thought Machines with the Model Context Protocol for humanoid robot control. The real novelty is the conceptual integration: running CTM as a continuous thinking layer that dynamically generates MCP tool calls, with a tick-slab runtime for parallel reasoning and rank compression to limit parameter growth. That addresses a real gap, since most MCP agents are stateless tool callers and CTM is a fresh idea. The author also deserves credit for engaging the relevant literature and for being unusually explicit about limitations in Section VI: the implementation is not real-time, LLM latency masks CTM's millisecond advantage, and the code only simulates logic, not accelerated execution.

The soft spots are severe and load-bearing. The experiments are not run in Isaac Sim, Gazebo, or any standard robotics simulator. Instead, the architecture code is passed into OpenAI's o4-mini-high chat session, which serves simultaneously as the simulation environment, the control group, the metric calculator, and the data interpreter. The same model computes TSR, ROSCOE, PSA, and the rest, with no independent ground truth. Section IV.C also says only the most stable results across nine epochs were selected for recording—that is selective reporting, not a fair comparison. The control group is not NVIDIA Isaac GR00T; it is an LLM role-play of Isaac GR00T in another chat session. The equations in the PDF are badly garbled, so the architecture's math cannot be fully checked. The claimed superiority over Isaac GR00T is therefore meaningless: both arms are the same LLM playing different roles.

The paper's own limitation section admits the central weakness: it cannot achieve responsive acceleration and the LLM introduces unpredictable latency. That means the empirical claim of feasibility and effectiveness collapses unless you accept that a chat model's semantic role-play is a valid simulation of humanoid control. I do not, and the stress-test note is right on the money.

Who should read this? Someone thinking about integrating CTM with tool-use frameworks might find the architectural sketch useful as a position piece, but the results should not be cited as evidence. The motivation is clear, the limitations are honestly stated, and the conceptual integration is novel, but the validation is not a serious empirical study.

I would not send this to peer review as a research contribution. The empirical core is unsound and the math is unverifiable as printed. If the author later runs the system in a real simulator with independent metrics, it could be worth revisiting. For now, it is an interesting idea in search of an experiment.

Referee Report

4 major / 4 minor

Summary. The paper proposes a CTM-MCP architecture for humanoid robot autonomy, combining a continuous-thought-machine runtime with a Model Context Protocol-based routing layer. The authors claim this architecture enables dynamic, perception-driven 'thinking-planning-acting' and report simulation experiments using OpenAI's o4-mini-high as the execution platform and an extended SayCan dataset. Nine epochs of comparisons against a control group described as NVIDIA Isaac GR00T are summarized in seven metrics (TSR, ESR, AEL, ROSCOE, REVEAL, PSA, TE), and the paper concludes that CTM-MCP breaks the logical bottleneck of existing models for humanoid robot autonomy.

Significance. If the central claim were supported, the paper would offer an interesting architectural proposal for integrating continuous latent-state reasoning with tool-call protocols. The manuscript also provides a fairly detailed module-level description and states that code is publicly available, which could facilitate reimplementation. However, the empirical evidence does not exercise the architecture in any robotics-capable setting: the system under test, the control group, the simulated environment, and the metric computation all reside in the same LLM chat session. The paper's own limitation section concedes that the code only simulates logic and cannot achieve responsive acceleration. Since the feasibility claim rests entirely on this self-referential evaluation, the significance of the reported results is currently very limited.

major comments (4)

[IV.A and IV.C] The experimental evidence for the central feasibility claim is self-referential. Section IV.C states that the researcher passed the framework code into OpenAI's o4-mini-high model to build the experimental environment, and Section V states that the same model 'stably convert[s] the execution results generated by each epoch experiment into quantifiable values.' Thus the system under test, the control group, the simulated environment, and the metric computation are all internal to a single LLM session. Without an independent robot simulator, a physical robot, or an external metric computation pipeline, the reported TSR, ESR, and AEL values do not provide evidence about the behavior of the proposed architecture on any actual robot control loop.
[IV.C] The protocol selects the most favorable outcome after the fact. The text states that 'only a set of results with the most stable performance and the most complete task logic are selected for recording,' while individual epochs underwent 'multiple debugging, restart and repair operations.' No pre-specified selection rule, raw logs from discarded runs, or independent audit trail is provided, so the nine epochs in Tables 1 and 2 cannot be treated as an unbiased sample. Consequently, the stability comparisons and variance claims in Section V are not statistically meaningful.
[IV.A and IV.C] The control group is not a run of NVIDIA Isaac GR00T. The researcher 'input the formatted and sequence-aligned NVIDIA Isaac GR00T code in another independent o4-mini-high dialogue session' and then imported the dataset into that session. Prompting an LLM with source code is not equivalent to executing the Isaac GR00T stack in a simulator or on hardware. The comparison therefore does not measure CTM-MCP against Isaac GR00T in any environment where either system's actual control behavior is observable.
[V and VI] The outcome metrics, including the proficiency self-assessment (PSA), are produced by the same model that performs the simulation, and the paper's own limitation section concedes that the code 'simulate[s] logic but cannot achieve responsive acceleration' and that LLM latency 'may mask CTM's millisecond adaptive computing advantage.' These admissions directly undermine the conclusion that the architecture 'enables humanoid robots to have the closed-loop ability to drive internal semantic thinking with scene perception.' At most, the results show that o4-mini-high can generate plausible quantitative summaries when given the architecture code, not that the architecture achieves autonomous robot control.

minor comments (4)

[III.F and VII] There are multiple typographical errors, including 'parallel branch nanager' in Section III.F and 'addresss' used twice in Section VII; these should be corrected.
[III.A and III.B] Several equations are garbled in the provided text, for example 'xtanh(y W=' and '])y||y||[y tanh( f proaudvisfW='. The algorithmic definitions cannot be checked unless the equations are properly typeset with a standard equation editor.
[IV.B] The synthesis of 900 additional SayCan tasks is described as verified through 'performance testing and semantic stability,' but no protocol, quantitative evidence, or examples of the synthetic tasks are provided, so the equivalence of the extended dataset to the original is not established.
[IV.C] The paper states that the experimental records are uploaded to a GitHub repository but gives no repository URL, commit identifier, or independently runnable metric-computation script; without these, the claimed 'data credibility and experimental traceability' cannot be assessed.

Circularity Check

2 steps flagged · score 7.0 of 10

Empirical case is self-evaluating: o4-mini-high both executes the CTM-MCP simulation and computes all seven metrics, so the feasibility claim is confirmed by the same agent under test.

self definitional [Section IV.C (Implementation) and Section V (Result & Discussion)]
"The researcher first passed the framework code and experimental code designed and tested by Python 3.13 IDLE into the OpenAI o4-mini-high model to build an experimental environment as the operating core of the semantic framework simulation environment. ... OpenAI's o4-mini-high model uses high-frequency memory maintenance and powerful computing power to stably convert the execution results generated by each epoch experiment into quantifiable values, which improves the objective reliability and validity of this study."

The architecture under evaluation is run inside o4-mini-high, and the same o4-mini-high model converts the execution traces into all reported metric values, including the self-rated proficiency self-assessment. There is no external simulator, no independent ground truth for task success, and no third-party computation of TSR, ESR, AEL, ROSCOE, REVEAL, PSA, or TE. The claimed confirmation of feasible and effective is therefore the evaluating agent's own judgment about its own execution of the test code; the outcome variable is defined by the same system whose behavior is being tested, making the empirical result self-referential rather than independently verified.
fitted input called prediction [Section IV.C (Implementation)]
"Finally, only a set of results with the most stable performance and the most complete task logic are selected for recording."

The paper later presents the architecture's high stability and continuous leadership across seven metrics as evidence of its merits. But the records used for that comparison were selected after the fact by the criterion most stable performance and most complete task logic. Selecting on the dependent variable and then reporting the selected values as evidence of stability makes the stability result an artifact of the selection rule, not an independent prediction or measurement of the architecture.

full rationale

The central claim that CTM-MCP is feasible and effective is supported only by a simulation in which OpenAI's o4-mini-high is simultaneously the execution platform, the control-group environment, and the converter of execution results into all seven metric values. This is a self-evaluation loop: the model that simulates the architecture also decides what the success and quality metrics are. The paper's own limitation section admits the code 'simulate[s] logic but cannot achieve responsive acceleration' and that 'the latency and quota limitations of LLMs may mask CTM's millisecond adaptive computing advantage,' further confirming that no real humanoid control loop was tested. The CTM and MCP components are adopted from external prior work, so the theoretical architecture is not definitionally circular; the circularity is in the evaluation procedure. Adding to this, the reported records were selected for stability and task completeness after multiple restarts, so the favorable comparison is partly constructed by the selection rule. Because the conclusion's empirical support reduces to the same model's self-assessment, the circularity is substantial, but the architecture still has independent theoretical content and could in principle be tested on a real simulator or hardware, so the score is 7 rather than 8-10.

Assumptions & free parameters 5 free parameters · 4 assumptions · 5 invented entities

The architecture introduces several hand-set hyperparameters and new modules whose effects are not isolated or validated. The central feasibility claim rests on LLM-based simulation and synthetic data, with no physical or independent validation.

free parameters (5)

decay=0.999 = 0.999
Used in the sync rank 1 updater to control temporal decay; chosen by hand with no tuning procedure.
LOGIT_SCALE=8.0 = 8.0
Scaling factor in the certainty estimator softmax; set manually without justification.
C=4 = 4
Number of logits in the certainty estimator; chosen by hand.
epsilon0=0.75, alpha=0.5 = 0.75, 0.5
Initial uncertainty gain and modulation sensitivity in the certainty modulator; set manually.
beta=0.9 = 0.9
Smoothing coefficient for the gated hidden-state carry; chosen by hand.

assumptions (4)

domain assumption The o4-mini-high LLM can faithfully execute the CTM-MCP architecture and produce valid control outputs.
The entire experiment runs inside a ChatGPT session; no physical robot or physics simulator is used. See Section IV.A.
domain assumption Synthetic SayCan tasks are valid substitutes for real robot tasks.
900 tasks were generated by semantic arrangement and checked only by performance testing and semantic stability, not by real execution. See Section IV.B.
domain assumption LLM-generated and self-reported metrics such as PSA measure real system performance.
The model converts execution results into quantifiable values; no external ground truth is provided. See Sections IV.C and V.
standard math Standard neural network equations are used as implemented without proof.
The paper relies on tanh, softmax, and linear projections without derivation; this is standard, but the equations are garbled in the manuscript. See Sections III.A-III.G.

invented entities (5)

Tick-slab CTM runtime
purpose: Provides parallel, multi-branch continuous thinking over slabs and ticks.
A new module built on Darlow et al.'s CTM; no independent validation outside this paper.
Low-rank mu-MLP
purpose: Compresses memory updates to limit parameter growth during thinking.
Uses kronecker-based tensor decomposition and shared low-rank factors; no ablation or independent test.
Sync rank 1 updater
purpose: Maintains temporal consistency between slabs via rank-1 synchronization.
Derived from neural phase synchronization; no independent evidence.
MCP envelope router
purpose: Packages thinking results into tool calls and manages confidence gating, branching, and timeouts.
Core integration module; no independent benchmark.
Affect decoder and certainty modulator
purpose: Adjusts decision thresholds based on an emotional state vector.
Introduced for emotion modulation; no evidence it improves control.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Towards Humanoid Robot Autonomy: A Dynamic Architecture Integrating Continuous thought Machines (CTM) and Model Context Protocol (MCP)." pith.science (2026). https://pith.science/paper/G64QLV5H

@misc{pith2026250519339,
  author       = {Pith},
  title        = {Pith review of: Towards Humanoid Robot Autonomy: A Dynamic Architecture Integrating Continuous thought Machines (CTM) and Model Context Protocol (MCP)},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/G64QLV5H}},
  note         = {Machine review of arXiv:2505.19339}
}

read the original abstract

To address the gaps between the static pre-set "thinking-planning-action" of humanoid robots in unfamiliar scenarios and the highly programmed "call tool-return result" due to the lack of autonomous coding capabilities, this work designs a dynamic architecture connecting continuous thought machines (CTM) and model context protocol (MCP). It proposes a theoretical parallel solution through tick-slab and uses rank compression to achieve parameter suppression to provide a solution for achieving autonomous actions due to autonomous coding. The researcher used a simulation-based experiment using OpenAI's o4-mini-high as a tool to build the experimental environment, and introduced the extended SayCan dataset to conduct nine epochs of experiments. The experimental results show that the CTM-MCP architecture is feasible and effective through the data results of seven metrics: task success rate (TSR), execution success rate (ESR), average episode length (AEL), ROSCOE, REVEAL, proficiency self-assessment (PSA), task effectiveness (TE). In practice, it provides a reference experience for exploring the autonomous dynamic coding of humanoid robots based on continuous thinking to achieve human-like autonomous actions.

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

21 extracted references · 11 canonical work pages

[1]

& Zeng, A

Ahn, M., Brohan, A., Brown, N., Chebotar, Y., Cortes, O., David, B., ... & Zeng, A. (2022). Do as i can, not as i say: Grounding language in robotic affordances. arXiv preprint arXiv:2204.01691

arXiv 2022
[2]

Anthropic. (2024). Introducing the Model Context Protocol. https://www.anthropic.com/news/model-context-protocol

work page 2024
[3]

Bärmann, L., Kartmann, R., Peller-Konrad, F., Niehues, J., Waibel, A., & Asfour, T. (2024). Incremental learning of humanoid robot behavior from natural interaction and large language models. Frontiers in Robotics and AI, 11, 1455375

work page 2024
[4]

A., Tsubouchi, T., Ruan, X., & Ohya, A

Bottega, J. A., Tsubouchi, T., Ruan, X., & Ohya, A. (2025). Are We Close to Realizing Self-Programming Robots That Overcome the Unexpected?. In 2025 IEEE/SICE International Symposium on System Integration (SII) (pp. 368-374). IEEE

work page 2025
[5]

Darlow, L., Regan, C., Risi, S., Seely, J., & Jones, L. (2025). Continuous Thought Machines. arXiv preprint arXiv:2505.05522

arXiv 2025
[6]

K., & Kumar, S

Ehtesham, A., Singh, A., Gupta, G. K., & Kumar, S. (2025). A survey of agent interoperability protocols: Model Context Protocol (MCP), Agent Communication Protocol (ACP), Agent-to-Agent Protocol (A2A), and Agent Network Protocol (ANP). arXiv preprint arXiv:2505.02279

arXiv 2025
[7]

B., Wasowski, A., & Dragule, S

Ghzouli, R., Berger, T., Johnsen, E. B., Wasowski, A., & Dragule, S. (2023). Behavior trees and state machines in robotics applications. IEEE Transactions on Software Engineering, 49(9), 4243-4267

work page 2023
[8]

S., & Kulkarni, P

Habler, I., Huang, K., Narajala, V. S., & Kulkarni, P. (2025). Building A Secure Agentic AI Application Leveraging A2A Protocol. arXiv preprint arXiv:2504.16902

arXiv 2025

Show all 21 references

[9]

Hou, X., Zhao, Y., Wang, S., & Wang, H. (2025). Model context protocol (mcp): Landscape, security threats, and future research directions. arXiv preprint arXiv:2503.23278

2025 arXiv
[10]

Krishnan, N. (2025). Advancing Multi-Agent Systems Through Model Context Protocol: Architecture, Implementation, and Applications. arXiv preprint arXiv:2504.21030

2025 arXiv
[11]

K., & Wang, L

Li, C., Zheng, P., Zhou, P., Yin, Y., Lee, C. K., & Wang, L. (2024). Unleashing mixed-reality capability in Deep Reinforcement Learning-based robot motion generation towards safe human – robot collaboration. Journal of Manufacturing Systems, 74, 411-421

2024
[12]

Li, X., Hsu, K., Gu, J., Pertsch, K., Mees, O., Walke, H. R., ... & Xiao, T. (2024). Evaluating real-world robot manipulation policies in simulation. arXiv preprint arXiv:2405.05941

2024 arXiv
[13]

S., & Habler, I

Narajala, V. S., & Habler, I. (2025). Enterprise-Grade Security for the Model Context Protocol (MCP): Frameworks and Mitigation Strategies. arXiv preprint arXiv:2504.08623

2025 arXiv
[14]

Saglam, A., & Papelis, Y. (2024). A simulation-based approach for evaluating shared control algorithms for mobile robots. In 2024 Annual Modeling and Simulation Conference (ANNSIM) (pp. 1-13). IEEE

2024
[15]

Sakal, N. (2025). What is Model Context Protocol (MCP)? How it simplifies AI integrations compared to APIs. https://norahsakal.com/blog/mcp-vs-api-model-context-protocol-expla ined/

2025
[16]

OpenAI. (2025). OpenAI moderation API. https://platform.openai.com/docs/guides/moderation

2025
[17]

Anthropic. (2022). Constitutional AI: Harmlessness from AI feedback. https://www.anthropic.com/research/constitutional-aiharmlessness-fro m-ai-feedback

2022
[18]

Salimpour, S., Peña-Queralta, J., Paez-Granados, D., Heikkonen, J., & Westerlund, T. (2025). Sim-to-Real Transfer for Mobile Robots with Reinforcement Learning: from NVIDIA Isaac Sim to Gazebo and Real ROS 2 Robots. arXiv preprint arXiv:2501.02902

2025 arXiv
[19]

Saunders, M., Lewis, P., & Thornhill, A. (2009). Research methods for business students. Pearson education

2009
[20]

Spong, M. W. (2022). An historical perspective on the control of robotic manipulators. Annual review of control, robotics, and autonomous systems, 5(1), 1-31

2022
[21]

& Zhang, W

Yang, Y., Chai, H., Song, Y., Qi, S., Wen, M., Li, N., ... & Zhang, W. (2025). A Survey of AI Agent Protocols. arXiv preprint arXiv:2504.16736

2025 arXiv

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [1]

& Zeng, A

Ahn, M., Brohan, A., Brown, N., Chebotar, Y., Cortes, O., David, B., ... & Zeng, A. (2022). Do as i can, not as i say: Grounding language in robotic affordances. arXiv preprint arXiv:2204.01691

arXiv 2022

[2] [2]

Anthropic. (2024). Introducing the Model Context Protocol. https://www.anthropic.com/news/model-context-protocol

work page 2024

[3] [3]

Bärmann, L., Kartmann, R., Peller-Konrad, F., Niehues, J., Waibel, A., & Asfour, T. (2024). Incremental learning of humanoid robot behavior from natural interaction and large language models. Frontiers in Robotics and AI, 11, 1455375

work page 2024

[4] [4]

A., Tsubouchi, T., Ruan, X., & Ohya, A

Bottega, J. A., Tsubouchi, T., Ruan, X., & Ohya, A. (2025). Are We Close to Realizing Self-Programming Robots That Overcome the Unexpected?. In 2025 IEEE/SICE International Symposium on System Integration (SII) (pp. 368-374). IEEE

work page 2025

[5] [5]

Darlow, L., Regan, C., Risi, S., Seely, J., & Jones, L. (2025). Continuous Thought Machines. arXiv preprint arXiv:2505.05522

arXiv 2025

[6] [6]

K., & Kumar, S

Ehtesham, A., Singh, A., Gupta, G. K., & Kumar, S. (2025). A survey of agent interoperability protocols: Model Context Protocol (MCP), Agent Communication Protocol (ACP), Agent-to-Agent Protocol (A2A), and Agent Network Protocol (ANP). arXiv preprint arXiv:2505.02279

arXiv 2025

[7] [7]

B., Wasowski, A., & Dragule, S

Ghzouli, R., Berger, T., Johnsen, E. B., Wasowski, A., & Dragule, S. (2023). Behavior trees and state machines in robotics applications. IEEE Transactions on Software Engineering, 49(9), 4243-4267

work page 2023

[8] [8]

S., & Kulkarni, P

Habler, I., Huang, K., Narajala, V. S., & Kulkarni, P. (2025). Building A Secure Agentic AI Application Leveraging A2A Protocol. arXiv preprint arXiv:2504.16902

arXiv 2025