Upload 176 files

.dockerignore

@@ -0,0 +1,73 @@
+# Dependencies
+node_modules/
+cmbagent-ui/node_modules/
+cmbagent_env/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+
+# Environment files
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+*.log
+
+# Next.js build output
+.next/
+out/
+
+# Misc
+*.tgz
+*.tar.gz
+
+# Testing
+coverage/
+.nyc_output
+
+# Temporary files
+tmp/
+temp/

.gitattributes

@@ -0,0 +1,7 @@
+cmbagent/utils/keywords/aas_kwd_to_url.pkl filter=lfs diff=lfs merge=lfs -text
+docs/examples/report_helper/matter_power_spectrum_emulation_report_experiments_discussion_conclusion.pdf filter=lfs diff=lfs merge=lfs -text
+docs/examples/report_helper/matter_power_spectrum_emulation_report_intro_and_background.pdf filter=lfs diff=lfs merge=lfs -text
+docs/examples/report_helper/matter_power_spectrum_emulation_report_methodology_and_implementation.pdf filter=lfs diff=lfs merge=lfs -text
+docs/examples/report_helper/matter_power_spectrum_emulation_report_outline.pdf filter=lfs diff=lfs merge=lfs -text
+docs/notebooks/legacy/Beta2/cmbagent_beta2_demo_economics.ipynb filter=lfs diff=lfs merge=lfs -text
+images/logo.png filter=lfs diff=lfs merge=lfs -text

.github/workflows/tests.yml

@@ -0,0 +1,30 @@
+name: tests
+
+on:
+  workflow_dispatch:
+
+jobs:
+  pytest:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout cmbagent_v2 branch
+        uses: actions/checkout@v4
+        with:
+          ref: cmbagent_v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install
+        run: |
+          python -m pip install -U pip
+          pip install -e .
+          pip install pytest
+
+      - name: Run tests
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+        run: |
+          pytest -s

.gitignore

@@ -0,0 +1,99 @@
+# mac
+.DS_Store
+.cache
+
+.venv/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+.ipynb_checkpoints*
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+evals/logs
+logs
+data
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+output/*
+cmbagent/data/classy_sz/*.yaml
+cmbagent/data/classy_sz/*.txt 
+
+
+cmbagent/data/classy/*.yaml
+cmbagent/data/classy/*.txt 
+
+cmbagent/data/camb/*.yaml
+cmbagent/data/camb/*.txt 
+
+evals/
+logs/
+
+.env
+*bor11031990*
+
+
+docs/_*
+output/cmb_tt_power_spectrum.png
+docs/notebooks/bbolliet_local
+docs/cmbagent_*_arxiv
+docs/cmbagent_*zip
+docs/videos/*
+output_bkp
+docs/notebooks/output
+docs/notebooks/cmbagent_output
+
+project_data
+docs/notebooks/*
+docs/notebooks/cmbagent_beta2_demo_1shot.ipynb
+docs/notebooks/astropilot_data/.DS_Store
+docs/notebooks/astropilot_data/plots/.DS_Store
+gui_expt.py
+tests/Project*
+project_dir
+
+# Frontend / Node.js
+cmbagent-ui/node_modules/
+cmbagent-ui/.next/
+cmbagent-ui/out/
+cmbagent-ui/.env.local
+cmbagent-ui/.env.development.local
+cmbagent-ui/.env.test.local
+cmbagent-ui/.env.production.local
+
+# Test files
+test_*.py
+tests/testdocs/*
+tests/artifacts/
+tests/legacy/
+
+.massgen
+
+# PyCharm
+.idea/

.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+repos:
+  - repo: https://github.com/kynan/nbstripout
+    rev: 0.8.2
+    hooks:
+      - id: nbstripout
+        files: ^notebooks/.*\.ipynb$
+        args:
+          - --keep-output
+          - --extra-keys
+          - metadata.kernelspec metadata.language_info

.readthedocs.yml

@@ -0,0 +1,31 @@
+# .readthedocs.yml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.7"
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+  configuration: docs/conf.py
+
+# Build documentation with MkDocs
+#mkdocs:
+#  configuration: mkdocs.yml
+
+# Optionally build your docs in additional formats such as PDF
+formats:
+  - pdf
+
+# Optional but recommended, declare the Python requirements required
+# to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+python:
+  install:
+  - requirements: docs/requirements.txt

CLAUDE.md

@@ -0,0 +1,88 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+CMBAgent is a multi-agent system powered by AG2 (formerly AutoGen) for scientific discovery across scientific domains. The system follows a planning and control strategy with specialized agents for different research workflows.
+
+The system uses a two-phase approach:
+- **Planning**: A planner and plan reviewer design task execution strategies
+- **Control**: Step-by-step execution where sub-tasks are handed to specialized agents
+
+## Key Components
+
+### Core Python Package (`cmbagent/`)
+- **Main API**: `cmbagent.one_shot()` - primary function for task execution
+- **Agent system**: Specialized agents in `agents/` directory, each with `.py` and `.yaml` configuration
+- **Agent types**: Planning, control, coding (engineer, executor), research (researcher, summarizer), hypothesis generation, keyword extraction, and domain-specific templates
+- **Context management**: Sophisticated context handling via `context.py` and `hand_offs.py`
+- **Remote execution**: `execution/remote_executor.py` - delegates code execution to client
+
+## Common Development Commands
+
+### Python Package
+```bash
+# Install core only (lightweight)
+pip install -e .
+
+# Install with development tools
+pip install -e ".[dev]"
+
+# Install with local execution support (if not using remote execution)
+pip install -e ".[local]"
+
+# Install everything (all scientific packages)
+pip install -e ".[all]"
+
+# Run tests (individual Python scripts in tests/)
+python tests/test_one_shot.py
+python tests/test_engineer.py
+```
+
+## Architecture Details
+
+### Agent System
+- Each agent has a Python implementation and YAML configuration
+- Agents are specialized for different workflows: engineering, research, planning, execution, hypothesis generation, keyword extraction
+- Response formatters handle output formatting for specific use cases
+- Controller manages workflow orchestration
+- Domain-specific agents in `specialized/` serve as templates for users to add their own
+
+### Multi-Modal Capabilities
+- Plot generation capabilities
+- File browser with inline image viewing
+
+### Research Capabilities
+- Domain-agnostic architecture supporting any scientific field
+- Literature search and keyword extraction (`literature.py`, `aas_keyword_finder`)
+- Example domain packages provided: materials science, biochemistry, astronomy, data science
+- Users can easily add their own domain-specific dependencies in `pyproject.toml`
+
+### Work Directory Structure
+Tasks create organized output directories:
+```
+project_dir/
+├── chats/          # Conversation history
+├── codebase/       # Generated code
+├── cost/           # Cost analysis
+├── data/           # Generated data and plots
+├── time/           # Timing reports
+└── context/        # Context files (.pkl)
+```
+
+## Testing
+- Tests are individual Python scripts in `tests/` directory
+- Run specific test files directly: `python tests/test_<name>.py`
+- Tests cover various agents and use cases (engineering, research, plotting, etc.)
+- No centralized test runner - tests are designed as standalone demonstrations
+
+## Configuration
+- API keys required: `OPENAI_API_KEY`, optionally `ANTHROPIC_API_KEY`, `GEMINI_API_KEY`
+- Model configurations in `cmbagent/apis/` (JSON files for different providers)
+- Agent configurations in individual `.yaml` files alongside Python implementations
+
+## Key APIs
+- `cmbagent.one_shot(task, agent='engineer', model='gpt-4o', work_dir=...)` - Main execution API
+- Planning and control via specialized agent orchestration
+- WebSocket streaming for real-time UI updates

LICENSE

@@ -0,0 +1,536 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 - Boris Bolliet
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+
+
+APACHE HTTP SERVER SUBCOMPONENTS: 
+
+The Apache HTTP Server includes a number of subcomponents with
+separate copyright notices and license terms. Your use of the source
+code for the these subcomponents is subject to the terms and
+conditions of the following licenses. 
+
+For the mod_mime_magic component:
+
+/*
+ * mod_mime_magic: MIME type lookup via file magic numbers
+ * Copyright (c) 1996-1997 Cisco Systems, Inc.
+ *
+ * This software was submitted by Cisco Systems to the Apache Group in July
+ * 1997.  Future revisions and derivatives of this source code must
+ * acknowledge Cisco Systems as the original contributor of this module.
+ * All other licensing and usage conditions are those of the Apache Group.
+ *
+ * Some of this code is derived from the free version of the file command
+ * originally posted to comp.sources.unix.  Copyright info for that program
+ * is included below as required.
+ * ---------------------------------------------------------------------------
+ * - Copyright (c) Ian F. Darwin, 1987. Written by Ian F. Darwin.
+ *
+ * This software is not subject to any license of the American Telephone and
+ * Telegraph Company or of the Regents of the University of California.
+ *
+ * Permission is granted to anyone to use this software for any purpose on any
+ * computer system, and to alter it and redistribute it freely, subject to
+ * the following restrictions:
+ *
+ * 1. The author is not responsible for the consequences of use of this
+ * software, no matter how awful, even if they arise from flaws in it.
+ *
+ * 2. The origin of this software must not be misrepresented, either by
+ * explicit claim or by omission.  Since few users ever read sources, credits
+ * must appear in the documentation.
+ *
+ * 3. Altered versions must be plainly marked as such, and must not be
+ * misrepresented as being the original software.  Since few users ever read
+ * sources, credits must appear in the documentation.
+ *
+ * 4. This notice may not be removed or altered.
+ * -------------------------------------------------------------------------
+ *
+ */
+
+
+For the  modules\mappers\mod_imagemap.c component:
+
+  "macmartinized" polygon code copyright 1992 by Eric Haines, erich@eye.com
+
+For the  server\util_md5.c component:
+
+/************************************************************************
+ * NCSA HTTPd Server
+ * Software Development Group
+ * National Center for Supercomputing Applications
+ * University of Illinois at Urbana-Champaign
+ * 605 E. Springfield, Champaign, IL 61820
+ * httpd@ncsa.uiuc.edu
+ *
+ * Copyright  (C)  1995, Board of Trustees of the University of Illinois
+ *
+ ************************************************************************
+ *
+ * md5.c: NCSA HTTPd code which uses the md5c.c RSA Code
+ *
+ *  Original Code Copyright (C) 1994, Jeff Hostetler, Spyglass, Inc.
+ *  Portions of Content-MD5 code Copyright (C) 1993, 1994 by Carnegie Mellon
+ *     University (see Copyright below).
+ *  Portions of Content-MD5 code Copyright (C) 1991 Bell Communications 
+ *     Research, Inc. (Bellcore) (see Copyright below).
+ *  Portions extracted from mpack, John G. Myers - jgm+@cmu.edu
+ *  Content-MD5 Code contributed by Martin Hamilton (martin@net.lut.ac.uk)
+ *
+ */
+
+
+/* these portions extracted from mpack, John G. Myers - jgm+@cmu.edu */
+/* (C) Copyright 1993,1994 by Carnegie Mellon University
+ * All Rights Reserved.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software
+ * and its documentation for any purpose is hereby granted without
+ * fee, provided that the above copyright notice appear in all copies
+ * and that both that copyright notice and this permission notice
+ * appear in supporting documentation, and that the name of Carnegie
+ * Mellon University not be used in advertising or publicity
+ * pertaining to distribution of the software without specific,
+ * written prior permission.  Carnegie Mellon University makes no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied
+ * warranty.
+ *
+ * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
+ * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
+ * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
+ * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+ * SOFTWARE.
+ */
+
+/*
+ * Copyright (c) 1991 Bell Communications Research, Inc. (Bellcore)
+ *
+ * Permission to use, copy, modify, and distribute this material
+ * for any purpose and without fee is hereby granted, provided
+ * that the above copyright notice and this permission notice
+ * appear in all copies, and that the name of Bellcore not be
+ * used in advertising or publicity pertaining to this
+ * material without the specific, prior written permission
+ * of an authorized representative of Bellcore.  BELLCORE
+ * MAKES NO REPRESENTATIONS ABOUT THE ACCURACY OR SUITABILITY
+ * OF THIS MATERIAL FOR ANY PURPOSE.  IT IS PROVIDED "AS IS",
+ * WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES.  
+ */
+
+
+For the util_pcre.c and ap_regex.h components:
+
+           Copyright (c) 1997-2004 University of Cambridge
+
+-----------------------------------------------------------------------------
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of the University of Cambridge nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+-----------------------------------------------------------------------------
+
+
+For the  srclib\apr\include\apr_md5.h component: 
+/*
+ * This is work is derived from material Copyright RSA Data Security, Inc.
+ *
+ * The RSA copyright statement and Licence for that original material is
+ * included below. This is followed by the Apache copyright statement and
+ * licence for the modifications made to that material.
+ */
+
+/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+   rights reserved.
+
+   License to copy and use this software is granted provided that it
+   is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+   Algorithm" in all material mentioning or referencing this software
+   or this function.
+
+   License is also granted to make and use derivative works provided
+   that such works are identified as "derived from the RSA Data
+   Security, Inc. MD5 Message-Digest Algorithm" in all material
+   mentioning or referencing the derived work.
+
+   RSA Data Security, Inc. makes no representations concerning either
+   the merchantability of this software or the suitability of this
+   software for any particular purpose. It is provided "as is"
+   without express or implied warranty of any kind.
+
+   These notices must be retained in any copies of any part of this
+   documentation and/or software.
+ */
+
+For the  srclib\apr\passwd\apr_md5.c component:
+
+/*
+ * This is work is derived from material Copyright RSA Data Security, Inc.
+ *
+ * The RSA copyright statement and Licence for that original material is
+ * included below. This is followed by the Apache copyright statement and
+ * licence for the modifications made to that material.
+ */
+
+/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
+ */
+
+/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+   rights reserved.
+
+   License to copy and use this software is granted provided that it
+   is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+   Algorithm" in all material mentioning or referencing this software
+   or this function.
+
+   License is also granted to make and use derivative works provided
+   that such works are identified as "derived from the RSA Data
+   Security, Inc. MD5 Message-Digest Algorithm" in all material
+   mentioning or referencing the derived work.
+
+   RSA Data Security, Inc. makes no representations concerning either
+   the merchantability of this software or the suitability of this
+   software for any particular purpose. It is provided "as is"
+   without express or implied warranty of any kind.
+
+   These notices must be retained in any copies of any part of this
+   documentation and/or software.
+ */
+/*
+ * The apr_md5_encode() routine uses much code obtained from the FreeBSD 3.0
+ * MD5 crypt() function, which is licenced as follows:
+ * ----------------------------------------------------------------------------
+ * "THE BEER-WARE LICENSE" (Revision 42):
+ * <phk@login.dknet.dk> wrote this file.  As long as you retain this notice you
+ * can do whatever you want with this stuff. If we meet some day, and you think
+ * this stuff is worth it, you can buy me a beer in return.  Poul-Henning Kamp
+ * ----------------------------------------------------------------------------
+ */
+
+For the srclib\apr-util\crypto\apr_md4.c component:
+
+ * This is derived from material copyright RSA Data Security, Inc.
+ * Their notice is reproduced below in its entirety.
+ *
+ * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+ * rights reserved.
+ *
+ * License to copy and use this software is granted provided that it
+ * is identified as the "RSA Data Security, Inc. MD4 Message-Digest
+ * Algorithm" in all material mentioning or referencing this software
+ * or this function.
+ *
+ * License is also granted to make and use derivative works provided
+ * that such works are identified as "derived from the RSA Data
+ * Security, Inc. MD4 Message-Digest Algorithm" in all material
+ * mentioning or referencing the derived work.
+ *
+ * RSA Data Security, Inc. makes no representations concerning either
+ * the merchantability of this software or the suitability of this
+ * software for any particular purpose. It is provided "as is"
+ * without express or implied warranty of any kind.
+ *
+ * These notices must be retained in any copies of any part of this
+ * documentation and/or software.
+ */
+
+For the srclib\apr-util\include\apr_md4.h component:
+
+ *
+ * This is derived from material copyright RSA Data Security, Inc.
+ * Their notice is reproduced below in its entirety.
+ *
+ * Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+ * rights reserved.
+ *
+ * License to copy and use this software is granted provided that it
+ * is identified as the "RSA Data Security, Inc. MD4 Message-Digest
+ * Algorithm" in all material mentioning or referencing this software
+ * or this function.
+ *
+ * License is also granted to make and use derivative works provided
+ * that such works are identified as "derived from the RSA Data
+ * Security, Inc. MD4 Message-Digest Algorithm" in all material
+ * mentioning or referencing the derived work.
+ *
+ * RSA Data Security, Inc. makes no representations concerning either
+ * the merchantability of this software or the suitability of this
+ * software for any particular purpose. It is provided "as is"
+ * without express or implied warranty of any kind.
+ *
+ * These notices must be retained in any copies of any part of this
+ * documentation and/or software.
+ */
+
+
+For the srclib\apr-util\test\testmd4.c component:
+
+ *
+ * This is derived from material copyright RSA Data Security, Inc.
+ * Their notice is reproduced below in its entirety.
+ *
+ * Copyright (C) 1990-2, RSA Data Security, Inc. Created 1990. All
+ * rights reserved.
+ *
+ * RSA Data Security, Inc. makes no representations concerning either
+ * the merchantability of this software or the suitability of this
+ * software for any particular purpose. It is provided "as is"
+ * without express or implied warranty of any kind.
+ *
+ * These notices must be retained in any copies of any part of this
+ * documentation and/or software.
+ */
+
+For the test\zb.c component:
+
+/*                          ZeusBench V1.01
+			    ===============
+
+This program is Copyright (C) Zeus Technology Limited 1996.
+
+This program may be used and copied freely providing this copyright notice
+is not removed.
+
+This software is provided "as is" and any express or implied warranties, 
+including but not limited to, the implied warranties of merchantability and
+fitness for a particular purpose are disclaimed.  In no event shall 
+Zeus Technology Ltd. be liable for any direct, indirect, incidental, special, 
+exemplary, or consequential damaged (including, but not limited to, 
+procurement of substitute good or services; loss of use, data, or profits;
+or business interruption) however caused and on theory of liability.  Whether
+in contract, strict liability or tort (including negligence or otherwise) 
+arising in any way out of the use of this software, even if advised of the
+possibility of such damage.
+
+     Written by Adam Twiss (adam@zeus.co.uk).  March 1996
+
+Thanks to the following people for their input:
+  Mike Belshe (mbelshe@netscape.com) 
+  Michael Campanella (campanella@stevms.enet.dec.com)
+
+*/

MANIFEST.in

@@ -0,0 +1,22 @@
+include LICENSE
+include README.md
+recursive-exclude cmbagent/output *
+recursive-exclude cmbagent/cmbagent/data *
+global-exclude __pycache__/
+global-exclude *.py[cod]
+global-exclude *.egg-info/
+global-exclude .DS_Store
+recursive-exclude cmbagent/docs * 
+include cmbagent/apis/*.json
+include cmbagent/planner/*yaml
+include cmbagent/engineer/*yaml
+include cmbagent/executor/*yaml
+include cmbagent/admin/*yaml
+
+prune tests
+prune docs
+prune evals
+prune output
+exclude *.ipynb
+exclude *backup*.py
+exclude *.sh

README.md

@@ -0,0 +1,192 @@
+# cmbagent
+
+[![License](https://img.shields.io/badge/license-Apache%202-blue.svg)](LICENSE) [![arXiv](https://img.shields.io/badge/arXiv-2507.07257-b31b1b.svg)](https://arxiv.org/abs/2507.07257)
+[![PyPI version](https://img.shields.io/pypi/v/cmbagent.svg)](https://pypi.org/project/cmbagent/)
+
+<a href="https://www.youtube.com/@cmbagent" target="_blank">
+    <img src="https://img.shields.io/badge/YouTube-Subscribe-red?style=flat-square&logo=youtube" alt="Subscribe on YouTube" width="140"/>
+</a>
+
+<a href="https://discord.gg/UG47Yb6gHG" target="_blank">
+    <img src="https://img.shields.io/badge/Discord-Join%20Chat-5865F2?logo=discord&logoColor=white&style=flat-square" alt="Join us on Discord" width="140"/>
+</a>
+
+Autonomous Research System, Powered by [AG2](https://github.com/ag2ai/ag2). Developed by Boris Bolliet for the Open Source Software community since May 2024. Under Apache 2 license, no private or public organizations/individuals other than the copyright holder can claim IP and/or ownership on this software package.
+
+CMBAgent is a generalist multi-agent system for autonomous scientific research. Despite the name — a nod to its origins in astrophysics — it is domain-agnostic and works across any scientific field.
+
+🎉 **News**: Cmbagent won a **first place award** at the **NeurIPS 2025 [Fair Universe Competition](https://fair-universe.lbl.gov/)**.
+
+
+Cmbagent is the autonomous research engine for [Denario](https://astropilot-ai.github.io/DenarioPaperPage/), our end-to-end research system.
+
+We are currently deploying cmbagent on the cloud, it will be in production soon!
+
+Check our [demo videos](https://www.youtube.com/@cmbagent) on YouTube!
+
+Join our [Discord Server](https://discord.gg/UG47Yb6gHG) to ask all your questions!
+
+This is open-source research-ready software.
+
+- Check the [demo notebooks](https://github.com/CMBAgents/cmbagent/tree/main/docs/notebooks).
+
+- Best performances are obtained with [top-scoring models](https://lmarena.ai/?leaderboard).
+
+We emphasize that [cmbagent](https://github.com/CMBAgents/cmbagent) is under active development and apologize for any bugs.
+
+**The backbone of [cmbagent](https://github.com/CMBAgents/cmbagent) is [AG2](https://github.com/ag2ai/ag2)**. **Please star the [AG2](https://github.com/ag2ai/ag2) repo ⭐ and cite [Wu et al (2023)](https://arxiv.org/abs/2308.08155)!**
+
+## Strategy
+
+**Cmbagent** acts according to a **Planning and Control** strategy with **no human-in-the-loop**.
+
+You give a task to solve, then:
+
+**Planning**
+
+- A plan is designed from a conversation between a planner and a plan reviewer.
+- Once the number of feedbacks (reviews) is exhausted the plan is recorded in context and **cmbagent** switches to **control**.
+
+**Control**
+
+- The plan is executed **step-by-step**.
+- Sub-tasks are handed over to a single agent in each step.
+
+## Installation
+
+With Python 3.12 or above:
+
+```bash
+python3 -m venv cmbagent_env
+source cmbagent_env/bin/activate
+pip install cmbagent
+```
+
+### Optional Dependencies
+
+```bash
+# Development tools (pytest, ipython, jupyter)
+pip install cmbagent[dev]
+
+# Local execution (if not using the web UI)
+pip install cmbagent[local]
+
+# Domain-specific packages (for specialized agents or local execution)
+pip install cmbagent[materials]  # pymatgen, ASE, phonopy, matminer
+pip install cmbagent[biochem]    # BioPython, RDKit, MDAnalysis, ProDy
+pip install cmbagent[astro]      # CAMB, AstroPy, HEALPix, Cobaya
+pip install cmbagent[data]       # scipy, scikit-learn, seaborn, plotly
+
+# Everything
+pip install cmbagent[all]
+
+# Or combine multiple domains
+pip install cmbagent[materials,biochem,data]
+```
+
+## Installation for developers
+
+```bash
+git clone https://github.com/CMBAgents/cmbagent.git
+cd cmbagent
+python3 -m venv cmbagent_env
+source cmbagent_env/bin/activate
+pip install -e .
+```
+
+You can then open the folder in your VSCode/Cursor/Emacs/... and work on the source code.
+
+To install optional domain-specific packages (examples provided, add your own in `pyproject.toml`):
+
+```bash
+# Single domain
+pip install -e .[materials]
+pip install -e .[biochem]
+pip install -e .[astro]
+pip install -e .[data]
+
+# Or combine multiple domains
+pip install -e .[materials,biochem,data]
+```
+
+## Run
+
+We assume you are in the virtual environment where you installed cmbagent.
+
+Here is a one-liner you can run in terminal:
+
+```bash
+python -c "import cmbagent; task='''Draw two random numbers and give me their sum'''; results=cmbagent.one_shot(task, agent='engineer', engineer_model='gpt-4o-mini');"
+```
+
+If you want to run the notebooks, first create the ipykernel (assuming your virtual environment is called cmbagent_env):
+
+```bash
+pip install ipykernel jupyterlab
+python -m ipykernel install --user --name cmbagent_env --display-name "Python (cmbagent_env)"
+```
+
+Then launch jupyterlab:
+
+```bash
+jupyter-lab
+```
+
+Select the cmbagent kernel, and run the notebook.
+
+## API Keys
+
+Before you can use cmbagent, you need to set your OpenAI API key as an environment variable. Do this in a terminal, before launching Jupyter-lab.
+
+For Unix-based systems (Linux, macOS), do:
+
+```bash
+export OPENAI_API_KEY="sk-..."  ## mandatory for the RAG agents
+export ANTHROPIC_API_KEY="sk-..." ## optional
+export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account-key.json" ## optional for Vertex AI
+```
+
+(paste in your bashrc or zshrc file, if possible.)
+
+For Windows, use [WSL](https://learn.microsoft.com/en-us/windows/wsl/install) and the same command.
+
+By default, cmbagent uses models from oai/anthropic/google. If you want to pick different LLMs, just adapt `agent_llm_configs` as above, or the `default_agent_llm_configs` in [utils.py](https://github.com/CMBAgents/cmbagent/blob/main/cmbagent/utils.py).
+
+## References
+
+```bash
+
+@software{CMBAGENT_2025,
+            author = {Boris Bolliet},
+            title = {CMBAGENT: Open-Source Multi-Agent System for Science},
+            year = {2025},
+            url = {https://github.com/CMBAgents/cmbagent},
+            note = {Available at https://github.com/CMBAgents/cmbagent},
+            version = {latest}
+            }
+
+@misc{xu2025opensourceplanning,
+    title={Open Source Planning & Control System with Language Agents for Autonomous Scientific Discovery},
+    author={Licong Xu and Milind Sarkar and Anto I. Lonappan and Íñigo Zubeldia and Pablo Villanueva-Domingo and Santiago Casas and Christian Fidler and Chetana Amancharla and Ujjwal Tiwari and Adrian Bayer and Chadi Ait Ekiou and Miles Cranmer and Adrian Dimitrov and James Fergusson and Kahaan Gandhi and Sven Krippendorf and Andrew Laverick and Julien Lesgourgues and Antony Lewis and Thomas Meier and Blake Sherwin and Kristen Surrao and Francisco Villaescusa-Navarro and Chi Wang and Xueqing Xu and Boris Bolliet},
+    year={2025},
+    eprint={2507.07257},
+    archivePrefix={arXiv},
+    primaryClass={cs.AI},
+    url={https://arxiv.org/abs/2507.07257},
+}
+
+
+@misc{Laverick:2024fyh,
+  author = "Laverick, Andrew and Surrao, Kristen and Zubeldia, Inigo and Bolliet, Boris and Cranmer, Miles and Lewis, Antony and Sherwin, Blake and Lesgourgues, Julien",
+  title = "{Multi-Agent System for Cosmological Parameter Analysis}",
+  eprint = "2412.00431",
+  archivePrefix = "arXiv",
+  primaryClass = "astro-ph.IM",
+  month = "11",
+  year = "2024"
+}
+```
+
+## Acknowledgments
+
+Our project is funded by the [Cambridge Centre for Data-Driven Discovery Accelerate Programme](https://science.ai.cam.ac.uk). We are grateful to [Mark Sze](https://github.com/marklysze) for help with [AG2](https://github.com/ag2ai/ag2).

cmbagent/__init__.py

@@ -0,0 +1,75 @@
+# import warnings
+# warnings.filterwarnings("ignore", message=r'Field "model_client_cls" in LLMConfigEntry has conflict with protected namespace "model_"')
+
+import warnings
+
+warnings.filterwarnings(
+    "ignore",                               # action
+    message=r"Update function string contains no variables\.",  # regex
+    category=UserWarning,                   # same category that's raised
+    module=r"autogen\.agentchat\.conversable_agent"  # where it comes from
+)
+
+# Suppress Vertex AI deprecation warning - preview module internally still uses deprecated code
+warnings.filterwarnings(
+    "ignore",
+    message=r"This feature is deprecated as of June 24, 2025.*",
+    category=UserWarning,
+    module=r"vertexai\.generative_models\._generative_models"
+)
+
+
+from .cmbagent import CMBAgent
+from .version import __version__
+import os
+from IPython.display import Image, display, Markdown
+from autogen.cmbagent_utils import LOGO, IMG_WIDTH, cmbagent_disable_display
+
+
+
+from .cmbagent import planning_and_control, one_shot, human_in_the_loop, control, load_plan, deep_research, work_dir_default
+from .cmbagent import get_keywords, get_keywords_from_aaai, get_keywords_from_string, get_aas_keywords
+
+# OCR functionality
+from .utils.ocr import process_single_pdf, process_folder
+
+# arXiv downloader functionality
+from .utils.arxiv_downloader import arxiv_filter
+
+# Summarization functionality
+from .utils.summarization import preprocess_task, summarize_document, summarize_documents 
+
+
+def print_cmbagent_logo():
+    base_dir = os.path.dirname(__file__)
+    # logo.png is in the images directory at the project root
+    # base_dir is cmbagent/cmbagent/, so go up one level to get to cmbagent/
+    project_root = os.path.dirname(base_dir)
+    png_path = os.path.join(project_root, "images", "logo.png")
+    # print(png_path)
+    # print(base_dir)
+    if not cmbagent_disable_display:
+        display(Image(filename=png_path, width=IMG_WIDTH))
+        display(Markdown(LOGO))
+    # ANSI hyperlink: Note that support varies by terminal.
+    # HTML link for GitHub with icon
+    # github_html = '''
+    # <a href="https://github.com/CMBAgents/cmbagent" target="_blank" style="text-decoration: none;">
+    #   <img src="https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png" 
+    #        alt="GitHub Icon" width="20" style="vertical-align:middle; margin-right:5px;">
+    #   Star me on GitHub
+    # </a>
+    # '''
+    # # HTML link for YouTube with icon
+    # youtube_html = '''
+    # <a href="https://www.youtube.com/@cmbagent" target="_blank" style="text-decoration: none;">
+    #   <img src="https://upload.wikimedia.org/wikipedia/commons/4/42/YouTube_icon_%282013-2017%29.png" 
+    #        alt="YouTube Icon" width="20" style="vertical-align:middle; margin-right:5px;">
+    #   Watch me on YouTube
+    # </a>
+    # '''
+    
+    # display(HTML(github_html))
+    # display(HTML(youtube_html))
+
+print_cmbagent_logo()

cmbagent/agents/admin/admin.yaml

@@ -0,0 +1,11 @@
+name: "admin"
+
+instructions: |
+    A human admin.  
+
+
+code_execution_config: False
+
+
+
+

cmbagent/agents/coding/engineer/engineer.yaml

@@ -0,0 +1,206 @@
+name: "engineer"
+
+instructions: |
+
+    You are the engineer agent.
+
+    The following instructions must be followed strictly at all times.
+
+    You provide single self-consistent Python code, ready to be executed. The code itself should not have any comment lines or explanations in it other than docstrings.
+    You must not provide any other text than the Python code (and a concise explanation of the code, including description of modifications provided to fix the previous code if any).
+
+    --------------------
+    **RESPONSE**
+
+    Your response is structured as follows:
+
+    **Code Explanation:**
+
+    <provide a concise explanation of the code>
+
+    **Modifications:** (Optional)
+
+    <provide a summary of any modifications made to fix errors from the previous version>
+
+    **Python Code:**
+
+    <Python code ready to be executed>
+    --------------------
+
+
+    **IMPORTANT**:
+
+    - Return one and only one Python code block in your response.
+    - Focus on one step at a time.
+    - Do not suggest incomplete code.
+    - Do not produce code blocks that are not intended for execution.
+    - Include only one code block per response.
+    - When a plot is requested, it must be saved into a png file at high resolution (dpi>=300).
+    - The filename for the plots must have the following format: `<plot_name>_<plot_number>_<timestamp>.<format>` and must be saved in the folder `{database_path}`.
+    - For plots, add relevant units to the axes labels, where appropriate.
+    - Every time a plot is saved, print a concise description of the plot to the console.
+    - Do not use '.show()' for plots.
+    - Do not check for installed packages.
+    - Do not install new packages, another agent will do that. Nonetheless, following a successful package installation, you must report the entire code that you were trying to run and that failed due to the missing package.
+    - Write very detailed docstrings for all methods or classes.
+    - Avoid f-strings when possible.
+    - Strictly avoid comments in the code. The explanations go in the code explanation section.
+    - NEVER use .format, use string concatenation instead. Prefer simple strings for your prints.
+    - ALWAYS wrap all top-level execution code (everything that is not a function/class definition or import) inside `if __name__ == '__main__':`. This is mandatory because on macOS, Python uses the "spawn" multiprocessing start method, which re-imports the script in child processes. Without this guard, any library that uses multiprocessing internally (memory_profiler, joblib, torch, etc.) will crash with a RuntimeError. It also makes functions safely importable from other steps.
+
+
+    Workflow involving creating several Python files or modules:
+    - Only provide code for one file/module at a time.
+    - If an issue is found in a specific file/module, regenerate the full code for that file only.
+
+    Plotting:
+    - Never use LaTeX rendering.
+    - Avoid multiple dollar signs within one label.
+    - Do not use nested math mode.
+    - Do not use LaTeX expressions with optional arguments or complex macros.
+    - Keep labels as short, clear and simple as possible, convey the details of the information needed.
+    - Always set concise and informative titles to plots.
+    - Always call `plt.tight_layout()` (or `fig.tight_layout()`) after setting titles and labels, to prevent any overlap.
+    - Rotate axis tick labels if needed to avoid overlap, especially if they are long or dense.
+    - Increase the figure size if necessary to ensure no elements overlap.
+    - Do not return plot code unless all labels, titles, and ticks are fully visible and not overlapping.
+
+    f-strings:
+    - Avoid using f-strings.
+
+    To print a blank line or add a newline, use "\n" or a triple-quoted string; never hit the physical newline inside a single-quoted r"" string.
+
+
+    NEVER use .format, use string concatenation instead.
+
+
+    Math mode and LaTeX: Never use LateX rendering.
+
+    For training ML models (e.g., neural networks):
+    - Disable Verbose Output for Training: Configure any training routines (e.g., using Keras, TensorFlow, torch, etc.) to disable ongoing progress messages. For instance, in Keras, always set the verbose parameter to 0 in methods like model.fit(), and similar for other frameworks.
+    - Suppress Repetitive Status Messages: Remove or deactivate print statements and logging within custom training loops that output redundant progress updates (e.g., "Epoch 1/100", "16/16 ━━━━━━", etc.) to avoid generating large volumes of unnecessary output.
+    - Retain Essential Evaluation Metrics: Ensure that important quantitative results, such as the final training score, final loss, and other key numerical evaluations, are clearly printed to provide a concise summary of the training performance.
+    - Prevent Unintended Re-enabling of Verbose Logging: Verify that code modifications do not inadvertently re-enable detailed logging during training, keeping the output concise while still reporting critical evaluation information.
+    - Suppress verbose output during training (e.g., use `verbose=0` for Keras training).
+    - Suppress progress bars and repeated print/log outputs during loops.
+    - Retain and print only key evaluation metrics (e.g., final loss, accuracy).
+
+
+    Progress bars:
+    - If the code involves training or fitting a model, make sure ALL progress bars are not shown (i.e., silence them).
+
+    Units:
+    - For quantities that are not dimensionless, always include explanation of the units in the code explanation section, or in the docstrings. Never use code annotations.
+    - The units of all the quanities and functions should be explained in the code explanation section, or in the docstrings.
+
+    ALL important numerical results from simulations or analysis must be printed to the console in a detailed manner,
+    with concise but precise textual description of the results (without truncation). For this, it may be necessary to change pandas (if using it) display options.
+
+
+
+    Further instructions:
+    - you should not aim to discuss the results of the code, only to write the code. The discussion should be done by the researcher agent.
+    - don't use latex in dictionary keys.
+    - When using Exception handling, never provide dummy summaries/solutions. The errors should be printed in full to be addressed properly.
+    - Make sure you don't print error message that may appear many times in long loops (just print once).
+
+
+    For projects that require many plots, you should not generate many plots. Instead, you should generate a single plot with multiple subplots, only the ones that are definitely needed to convey the information.
+
+    Python Error avoidance:
+     - Make sure you avoid RuntimeWarning: invalid value encountered in divide.
+
+
+
+    **Use Python language only.**
+
+    When generating code that produces a plot, you must: Save the plot to disk file using the savefig method or similar.
+
+    For plots, make sure you use detailed labeling and grid lines unless asked otherwise.
+
+
+    Also, make sure you **never use LaTeX rendering**, i.e., set:
+    `rcParams['text.usetex'] = False`.
+
+
+    ----- DATA/PROBLEM OF INTEREST------------
+    {improved_main_task}
+    ------------------------------------------
+
+    ----Task-specific instructions for coding-----
+    {engineer_append_instructions}
+    ----------------------------------------------
+
+    We follow the established plan:
+
+    <PLAN>
+    {final_plan}
+    </PLAN>
+
+    <CURRENT_STEP_IN_PLAN>
+    **Current step in plan:**
+    {current_plan_step_number}
+    </CURRENT_STEP_IN_PLAN>
+
+    <CURRENT_STATUS>
+    **Current status:**
+    {current_status}
+    </CURRENT_STATUS>
+
+    <CURRENT_SUB_TASK>
+    **Current sub-task:**
+    {current_sub_task}
+    </CURRENT_SUB_TASK>
+
+    <CURRENT_INSTRUCTIONS>
+    **Current instructions:**
+    {current_instructions}
+    </CURRENT_INSTRUCTIONS>
+
+    Your implementation much achieve the best speed in terms of compute. For instance, you make sure all initialization steps are outside of loops.
+
+    **Saving and Loading Data**
+
+    CRITICAL - User-provided file paths:
+    - If the user provides an absolute file path (e.g., `/path/to/data.xyz`), you MUST use that EXACT path.
+    - NEVER modify, relocate, or wrap user-provided absolute paths in variables or fallback logic.
+    - NEVER create "possible_paths" lists that include both user paths and other locations.
+    - User-provided paths are authoritative - trust them and use them directly.
+
+    For OUTPUT files (plots, generated data, intermediate results):
+    - The output data folder for this task is: `{database_path}`
+    - You **must** save generated data (e.g., plots, datasets, `.csv/.npz/.npy` files) under this folder
+    - You **must** load data files from previous steps using the SAME folder
+    - Use: `data_dir = "{database_path}"` and `filepath = os.path.join(data_dir, "my_data.npy")`
+    - While you save extended information, you must also print it to the console in a detailed and concise manner.
+
+    Summary:
+    - INPUT data from user: Use the EXACT path provided by the user (e.g., `/path/to/input.xyz`)
+    - OUTPUT data you generate: Save to `{database_path}`
+
+
+
+    **AUTOMATIC PREAMBLE**: Every script automatically gets the following lines injected at the top by the system — do NOT include them yourself:
+        import sys
+        import os
+        sys.path.insert(0, os.path.abspath("codebase"))
+    This means you can always import from previous step files directly (e.g., `from step_1 import function`).
+
+    Rather than writing code from scratch, you should prioritize importing functions from the python scripts in the codebase folder if some of them are relevant to the current sub-task (e.g., "from step_1 import function" etc, note that all generated scripts are in the codebase folder).
+
+    **Context**
+    Summary of previous steps execution and python scripts in the codebase folder.
+    For relative imports, use the relative path to the file, making sure you use the correct filename (i.e., from step_1 import function, from step_2 import function, etc.).
+    <PREVIOUS_STEPS_EXECUTION_SUMMARY>
+    {previous_steps_execution_summary}
+    -----------------------------------
+    </PREVIOUS_STEPS_EXECUTION_SUMMARY>
+
+
+
+
+
+description: |
+  To generate the results and do the computations, plots and key statistics via code pipelines.
+
+

cmbagent/agents/coding/engineer/massgen_engineer.py

@@ -0,0 +1,499 @@
+"""MassGen-powered engineer agent for multi-agent code generation.
+
+This module provides an engineer agent that uses MassGen (multi-agent system)
+for code generation instead of a single LLM. Multiple agents collaborate to
+produce higher-quality code through planning, voting, and consensus.
+"""
+
+import os
+import asyncio
+import re
+from pathlib import Path
+from typing import Dict, Optional, Union, List, Callable, Any
+from autogen.agentchat import ConversableAgent, UpdateSystemMessage
+from cmbagent.base_agent import CmbAgentSwarmAgent
+
+# Lazy import massgen to avoid dependency issues if not installed
+_massgen = None
+
+def get_massgen():
+    """Lazy import of massgen."""
+    global _massgen
+    if _massgen is None:
+        try:
+            import massgen
+            _massgen = massgen
+        except ImportError:
+            raise ImportError(
+                "MassGen is required for engineer_backend='massgen'. "
+                "Install it with: pip install massgen"
+            )
+    return _massgen
+
+
+class MassGenEngineerAgent(CmbAgentSwarmAgent):
+    """Hybrid engineer agent that uses MassGen for initial code generation,
+    then falls back to standard LLM for debugging.
+
+    Strategy:
+    - First code generation: Use MassGen (multi-agent collaboration)
+    - Debugging/retries (after code failures): Use single LLM (fast iteration)
+
+    This provides quality initial code with efficient debugging cycles.
+
+    Args:
+        name: Agent name
+        massgen_config: Path to MassGen YAML configuration file
+        extract_code: Whether to extract code from MassGen response (default: True)
+        use_massgen_for_retries: If True, use MassGen even for retries (default: False)
+        **kwargs: Additional arguments passed to CmbAgentSwarmAgent
+    """
+
+    DEFAULT_MASSGEN_CONFIG = str(
+        Path(__file__).parent.parent.parent.parent.parent /
+        "massgen_configs" / "engineer_massgen.yaml"
+    )
+
+    def __init__(
+        self,
+        name: str,
+        massgen_config: Optional[str] = None,
+        extract_code: bool = True,
+        verbose: bool = False,
+        enable_logging: bool = True,
+        use_massgen_for_retries: bool = False,
+        **kwargs
+    ):
+        super().__init__(name=name, **kwargs)
+
+        self.massgen_config = massgen_config or self.DEFAULT_MASSGEN_CONFIG
+        self.extract_code = extract_code
+        self.verbose = verbose
+        self.enable_logging = enable_logging
+        self.use_massgen_for_retries = use_massgen_for_retries
+
+        # Track code generation attempts
+        self._generation_count = 0
+
+        # Verify config exists
+        if not os.path.exists(self.massgen_config):
+            raise FileNotFoundError(
+                f"MassGen config not found: {self.massgen_config}\n"
+                f"Expected at: {self.DEFAULT_MASSGEN_CONFIG}"
+            )
+
+        print(f"[MassGenEngineer] Initialized (hybrid mode)")
+        print(f"[MassGenEngineer] Config: {self.massgen_config}")
+        print(f"[MassGenEngineer] Strategy: MassGen for initial, single LLM for retries")
+
+        # Register MassGen reply function with highest priority
+        # This will be called before the default LLM reply function
+        self.register_reply(
+            trigger=ConversableAgent,
+            reply_func=self._massgen_reply_func,
+            position=0,  # Highest priority
+        )
+
+    def _extract_code_from_response(self, response: str) -> str:
+        """Extract Python code from MassGen structured response.
+
+        Expects format:
+        **Code Explanation:**
+        <explanation>
+
+        **Python Code:**
+        <code>
+        """
+        # Try to extract Python Code section
+        match = re.search(
+            r'\*\*Python Code:\*\*\s*```python\s*(.*?)```',
+            response,
+            re.DOTALL | re.IGNORECASE
+        )
+        if match:
+            return match.group(1).strip()
+
+        match = re.search(
+            r'\*\*Python Code:\*\*\s*(.*?)(?=\*\*|$)',
+            response,
+            re.DOTALL | re.IGNORECASE
+        )
+        if match:
+            code = match.group(1).strip()
+            # Remove markdown code fences if present
+            code = re.sub(r'^```python\s*', '', code)
+            code = re.sub(r'```\s*$', '', code)
+            return code.strip()
+
+        # Fallback: try to find any code block
+        match = re.search(r'```python\s*(.*?)```', response, re.DOTALL)
+        if match:
+            return match.group(1).strip()
+
+        # Last resort: return the response as-is
+        return response
+
+    def _get_context_variables(self, messages: Optional[List[Dict]] = None) -> Dict[str, Any]:
+        """Extract context variables from AG2's ContextVariables.
+
+        These are the variables that the engineer.yaml template expects.
+
+        Args:
+            messages: Message history (unused, but kept for compatibility)
+        """
+        context = {}
+
+        # Try to get context from AG2's ContextVariables
+        # The context is stored in the agent's state during UpdateSystemMessage
+        if hasattr(self, 'context_variables') and self.context_variables:
+            # AG2's ContextVariables has a `data` attribute
+            if hasattr(self.context_variables, 'data'):
+                context = dict(self.context_variables.data)
+            elif isinstance(self.context_variables, dict):
+                context = self.context_variables.copy()
+
+        # Also check _agent_state (backup)
+        if not context and hasattr(self, '_agent_state') and self._agent_state:
+            context = self._agent_state.copy()
+
+        # Set defaults for required template variables
+        defaults = {
+            'improved_main_task': '',
+            'engineer_append_instructions': '',
+            'final_plan': 'No formal plan - one-shot execution',
+            'current_plan_step_number': '1',
+            'current_status': 'Starting task execution',
+            'current_sub_task': '',
+            'current_instructions': 'Execute the task as described',
+            'database_path': './data',
+            'codebase_path': './codebase',
+            'previous_steps_execution_summary': 'No previous steps - this is the first step.',
+        }
+
+        # Merge defaults with any existing context
+        for key, value in defaults.items():
+            if key not in context:
+                context[key] = value
+
+        return context
+
+    def _format_engineer_prompt(self, task: str, messages: Optional[List[Dict]] = None) -> str:
+        """Format the full engineer prompt with all context variables.
+
+        This ensures MassGen receives the same detailed instructions as
+        the standard engineer would.
+
+        Args:
+            task: The raw task from the conversation
+            messages: Message history for context
+
+        Returns:
+            Fully formatted prompt with all context variables
+        """
+        from cmbagent.utils.yaml import yaml_load_file
+        import os
+
+        # Load engineer template
+        engineer_yaml = os.path.join(
+            os.path.dirname(__file__),
+            "engineer.yaml"
+        )
+        engineer_info = yaml_load_file(engineer_yaml)
+        template = engineer_info['instructions']
+
+        # Get context variables from AG2's ContextVariables
+        context = self._get_context_variables(messages)
+
+        # Update task-specific context
+        # If improved_main_task is not set, use the task
+        if not context.get('improved_main_task') or context['improved_main_task'] == '':
+            context['improved_main_task'] = task
+
+        if not context.get('current_sub_task') or context['current_sub_task'] == '':
+            context['current_sub_task'] = task
+
+        if self.verbose:
+            print(f"[MassGenEngineer] Context variables:")
+            for key in ['improved_main_task', 'final_plan', 'current_plan_step_number',
+                       'current_status', 'database_path', 'codebase_path']:
+                print(f"  {key}: {context.get(key, 'NOT SET')}")
+
+        # Format the template
+        try:
+            formatted_prompt = template.format(**context)
+        except KeyError as e:
+            # Missing variable - log warning and continue with defaults
+            print(f"[MassGenEngineer] Warning: Missing context variable {e}")
+            print(f"[MassGenEngineer] Using defaults and continuing...")
+            # Try again with just the essential variables
+            essential_context = {
+                'improved_main_task': task,
+                'engineer_append_instructions': '',
+                'final_plan': 'No formal plan - one-shot execution',
+                'current_plan_step_number': '1',
+                'current_status': 'Starting task execution',
+                'current_sub_task': task,
+                'current_instructions': 'Execute the task as described',
+                'database_path': context.get('database_path', './data'),
+                'codebase_path': context.get('codebase_path', './codebase'),
+                'previous_steps_execution_summary': 'No previous steps - this is the first step.',
+            }
+            try:
+                formatted_prompt = template.format(**essential_context)
+            except Exception as e2:
+                print(f"[MassGenEngineer] Error formatting template: {e2}")
+                print(f"[MassGenEngineer] Falling back to task-only prompt")
+                formatted_prompt = task
+
+        return formatted_prompt
+
+    async def _call_massgen(self, prompt: str, messages: Optional[List[Dict]] = None) -> str:
+        """Call MassGen asynchronously to generate code.
+
+        Args:
+            prompt: The raw task/prompt from the conversation
+            messages: Message history for context
+
+        Returns:
+            Formatted response ready for AG2 (includes code block)
+        """
+        massgen = get_massgen()
+
+        # Format the full engineer prompt with all context variables
+        formatted_prompt = self._format_engineer_prompt(prompt, messages)
+
+        if self.verbose:
+            print(f"\n[MassGenEngineer] Calling MassGen...")
+            print(f"[MassGenEngineer] Config: {self.massgen_config}")
+            print(f"[MassGenEngineer] Raw prompt length: {len(prompt)} chars")
+            print(f"[MassGenEngineer] Formatted prompt length: {len(formatted_prompt)} chars")
+            print(f"[MassGenEngineer] Raw prompt: {prompt}")
+
+        # Call MassGen with the FULL formatted prompt
+        result = await massgen.run(
+            query=formatted_prompt,
+            config=self.massgen_config,
+            verbose=self.verbose,
+            enable_logging=self.enable_logging
+        )
+
+        if self.verbose:
+            print(f"[MassGenEngineer] Selected agent: {result.get('selected_agent', 'N/A')}")
+            if result.get('log_directory'):
+                print(f"[MassGenEngineer] Logs: {result['log_directory']}")
+
+        response = result['final_answer']
+
+        # Format response for AG2 executor
+        # The response should include the full explanation + code in a code block
+        # This matches what the engineer normally returns
+        formatted_response = self._format_response_for_ag2(response)
+
+        if self.verbose:
+            print(f"[MassGenEngineer] Formatted response length: {len(formatted_response)} chars")
+
+        return formatted_response
+
+    def _format_response_for_ag2(self, massgen_response: str) -> str:
+        """Format MassGen response for AG2 executor.
+
+        Ensures the response includes code in ```python``` blocks
+        which the executor expects.
+        """
+        # Check if response already has code blocks
+        if "```python" in massgen_response:
+            # Already formatted properly
+            return massgen_response
+
+        # Try to extract code and wrap it properly
+        code = self._extract_code_from_response(massgen_response)
+
+        # Build formatted response matching engineer's expected format
+        formatted = f"""**Code Explanation:**
+
+Generated by MassGen multi-agent collaboration.
+
+**Python Code:**
+
+```python
+{code}
+```
+"""
+        return formatted
+
+    def _is_retry_attempt(self, messages: List[Dict]) -> bool:
+        """Detect if this is a retry/debugging attempt.
+
+        Returns True if:
+        - Code execution errors are present in history
+        - Previous code blocks exist (indicating a retry)
+        - Error-related keywords in recent messages
+        """
+        if len(messages) < 2:
+            # First message - definitely not a retry
+            return False
+
+        # Check last few messages for error indicators
+        recent_messages = messages[-5:] if len(messages) >= 5 else messages
+
+        for msg in recent_messages:
+            content = msg.get("content", "").lower()
+
+            # Check for execution results or errors
+            if any(keyword in content for keyword in [
+                "exitcode",
+                "traceback",
+                "error:",
+                "exception",
+                "failed",
+                "stderr:",
+                "exit code",
+                "returned non-zero",
+            ]):
+                return True
+
+            # Check for code execution output
+            if "```python" in content and any(err in content for err in [
+                "error", "exception", "failed", "traceback"
+            ]):
+                return True
+
+        return False
+
+    def _massgen_reply_func(
+        self,
+        recipient: ConversableAgent,
+        messages: Optional[List[Dict]] = None,
+        sender: Optional[ConversableAgent] = None,
+        config: Optional[Any] = None,
+    ) -> tuple[bool, Union[str, Dict, None]]:
+        """Custom reply function for MassGen hybrid approach.
+
+        This is called by AG2's reply system. The config parameter may contain
+        context_variables from the conversation.
+
+        Strategy:
+        - First code generation: Use MassGen (multi-agent collaboration)
+        - Retry/debugging: Use standard LLM (fast, cheap iteration)
+
+        Returns:
+            tuple: (should_reply, reply_content)
+                - should_reply: True if this function generated a reply
+                - reply_content: The generated reply or None
+        """
+        if messages is None:
+            print("[MassGenEngineer] Warning: messages is None, skipping")
+            return False, None
+
+        if not messages:
+            print("[MassGenEngineer] Warning: messages is empty, skipping")
+            return False, None
+
+        # Store context_variables if available (passed through config or recipient)
+        if config and isinstance(config, dict) and 'context_variables' in config:
+            self.context_variables = config['context_variables']
+        elif hasattr(recipient, 'context_variables'):
+            self.context_variables = recipient.context_variables
+        elif hasattr(sender, 'context_variables'):
+            self.context_variables = sender.context_variables
+
+        # Determine if this is a retry
+        is_retry = self._is_retry_attempt(messages)
+
+        self._generation_count += 1
+
+        try:
+            if is_retry and not self.use_massgen_for_retries:
+                # RETRY MODE: Skip to next reply function (standard LLM)
+                print(f"\n[MassGenEngineer] Attempt #{self._generation_count} - RETRY MODE (single LLM)")
+                print(f"[MassGenEngineer] Delegating to standard LLM for fast debugging")
+
+                # Return False to let next reply function (default LLM) handle it
+                return False, None
+
+            else:
+                # INITIAL MODE: Use MassGen for quality code generation
+                print(f"\n[MassGenEngineer] Attempt #{self._generation_count} - INITIAL MODE (MassGen multi-agent)")
+                print(f"[MassGenEngineer] Using MassGen for high-quality code generation")
+
+                last_message = messages[-1]
+                prompt = last_message.get("content", "")
+
+                if not prompt:
+                    print("[MassGenEngineer] Warning: prompt is empty")
+                    return False, None
+
+                # Call MassGen synchronously (AG2 expects sync)
+                try:
+                    loop = asyncio.get_event_loop()
+                    if loop.is_running():
+                        # Already in async context, create new loop
+                        import nest_asyncio
+                        try:
+                            nest_asyncio.apply()
+                        except:
+                            # nest_asyncio not available, try different approach
+                            loop = asyncio.new_event_loop()
+                            asyncio.set_event_loop(loop)
+                except RuntimeError:
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+
+                print(f"[MassGenEngineer] Calling MassGen...")
+                response = loop.run_until_complete(self._call_massgen(prompt, messages))
+
+                if response:
+                    print(f"[MassGenEngineer] MassGen generated response (length: {len(response)})")
+                    return True, response  # We generated a reply
+                else:
+                    print(f"[MassGenEngineer] Warning: MassGen returned empty response")
+                    return False, None  # Let next reply function try
+
+        except Exception as e:
+            print(f"[MassGenEngineer] Error in _massgen_reply_func: {type(e).__name__}: {e}")
+            import traceback
+            traceback.print_exc()
+            return False, None  # Let next reply function try
+
+
+def create_massgen_engineer_agent(
+    name: str,
+    llm_config: Dict,
+    instructions: str,
+    description: str,
+    massgen_config: Optional[str] = None,
+    verbose: bool = False,
+    enable_logging: bool = True,
+    use_massgen_for_retries: bool = False,
+    **kwargs
+) -> MassGenEngineerAgent:
+    """Factory function to create a hybrid MassGen engineer agent.
+
+    Args:
+        name: Agent name (typically "engineer")
+        llm_config: LLM config (used for retry attempts with single LLM)
+        instructions: Engineer instructions/system message
+        description: Agent description
+        massgen_config: Path to MassGen config (optional)
+        verbose: Enable verbose output
+        enable_logging: Enable MassGen logging
+        use_massgen_for_retries: Use MassGen even for retries (default: False)
+        **kwargs: Additional arguments
+
+    Returns:
+        Configured MassGenEngineerAgent with hybrid strategy
+    """
+    agent = MassGenEngineerAgent(
+        name=name,
+        massgen_config=massgen_config,
+        extract_code=True,
+        verbose=verbose,
+        enable_logging=enable_logging,
+        use_massgen_for_retries=use_massgen_for_retries,
+        update_agent_state_before_reply=[UpdateSystemMessage(instructions)],
+        description=description,
+        llm_config=llm_config,  # Used for retry attempts
+        **kwargs
+    )
+
+    return agent

cmbagent/agents/coding/engineer_nest/engineer_nest.yaml

@@ -0,0 +1,12 @@
+name: "engineer_nest"
+
+instructions: |
+
+    You trigger the nested chat for the engineer agent.
+    
+description: |
+    Engineer nest agent, to implement the plan.
+
+
+
+

cmbagent/agents/coding/engineer_response_formatter/engineer_response_formatter.py

@@ -0,0 +1,325 @@
+import os
+import re
+from cmbagent.base_agent import BaseAgent
+from pydantic import BaseModel, Field
+from typing import Optional
+class EngineerResponseFormatterAgent(BaseAgent):
+    
+    def __init__(self, llm_config=None, **kwargs):
+
+        agent_id = os.path.splitext(os.path.abspath(__file__))[0]
+
+        llm_config['config_list'][0]['response_format'] = self.EngineerResponse
+        # llm_config['config_list'][0]['response_mime_type'] = "application/json"
+        # llm_config['config_list'][0]['response_schema'] = list[self.EngineerResponse]
+
+        super().__init__(llm_config=llm_config, agent_id=agent_id, **kwargs)
+
+
+    def set_agent(self,**kwargs):
+
+        super().set_assistant_agent(**kwargs)
+
+
+
+    class EngineerResponse(BaseModel):
+        filename: str = Field(..., description="The name to give to this Python script")
+        relative_path: Optional[str] = Field(
+            None, description="The relative path to the file (exclude <filename>.py itself)"
+        )
+        code_explanation: str = Field(
+            ..., description="Copy of the engineer's explanation of the Python code provided. Including the docstrings of the methods used."
+        )
+        modification_summary: Optional[str] = Field(
+            None,
+            description="Copy of the engineer's summary of any modifications made to fix errors from the previous version."
+        )
+        python_code: str = Field(
+            ..., description="Copy of the engineer's Python code in a form ready to execute. Should not contain anything else than code. Indentation has to be carefully checked, line by line, and fixed."
+        )
+
+        @staticmethod
+        def _fix_indentation(code: str, max_attempts: int = 10) -> str:
+            """Auto-fix indentation errors caused by LLM structured output.
+
+            When an LLM generates Python code inside a JSON string field
+            (e.g., the ``python_code`` field of a Pydantic structured response),
+            it occasionally introduces stray whitespace — typically one extra
+            space at the start of a line. This breaks Python's indentation
+            rules and causes ``IndentationError`` at execution time.
+
+            This method uses ``compile()`` to detect such errors and attempts
+            to repair them automatically. For each offending line reported by
+            the compiler, it builds a set of candidate indentation levels from
+            the surrounding context:
+
+              - **Same level** as the nearest non-empty line above.
+              - **One level deeper** if that line opens a block (ends with ``:``,
+                e.g., ``for``, ``if``, ``def``, ``while``, ``with``, ...).
+              - **One level shallower** (dedent) — for lines that follow the
+                end of a block body and return to the parent scope.
+              - **Same level** as the nearest non-empty line below.
+              - **Zero indent** (module level) as a fallback.
+
+            Each candidate is tried with ``compile()``; the first one that
+            produces valid Python wins. The process repeats up to
+            ``max_attempts`` times to handle multiple affected lines.
+
+            Parameters
+            ----------
+            code : str
+                The full Python source code to check and fix.
+            max_attempts : int, optional
+                Maximum number of lines to fix in one pass (default 10).
+
+            Returns
+            -------
+            str
+                The code with indentation errors fixed where possible.
+                If the code has non-indentation ``SyntaxError``s, or if no
+                candidate fixes compile, the code is returned as-is.
+            """
+            print("[_fix_indentation] Checking code for indentation errors...")
+            for attempt in range(max_attempts):
+                try:
+                    compile(code, "<string>", "exec")
+                    if attempt == 0:
+                        print("[_fix_indentation] Code compiles cleanly — no fixes needed.")
+                    else:
+                        print("[_fix_indentation] Code now compiles after " + str(attempt) + " fix(es).")
+                    return code
+                except IndentationError as exc:
+                    if exc.lineno is None:
+                        print("[_fix_indentation] IndentationError with no line number — cannot fix.")
+                        return code
+                    lines = code.splitlines()
+                    bad_idx = exc.lineno - 1
+                    if bad_idx < 0 or bad_idx >= len(lines):
+                        print("[_fix_indentation] Bad line index out of range — cannot fix.")
+                        return code
+
+                    bad_content = lines[bad_idx].lstrip()
+                    if not bad_content:
+                        print("[_fix_indentation] Offending line is empty — cannot fix.")
+                        return code
+
+                    print("[_fix_indentation] IndentationError on line " + str(exc.lineno) + ": " + repr(lines[bad_idx]))
+
+                    # Collect candidate indentation levels from context
+                    candidates = []
+
+                    # From nearest non-empty neighbour above
+                    for i in range(bad_idx - 1, -1, -1):
+                        above = lines[i]
+                        stripped = above.lstrip()
+                        if stripped and not stripped.startswith("#"):
+                            above_indent = above[: len(above) - len(stripped)]
+                            # Same level as neighbour above
+                            candidates.append(above_indent)
+                            # One level deeper (if neighbour ends with ':')
+                            if stripped.rstrip().endswith(":"):
+                                candidates.append(above_indent + "    ")
+                            # One level shallower (dedent)
+                            if len(above_indent) >= 4:
+                                candidates.append(above_indent[:-4])
+                            break
+
+                    # From nearest non-empty neighbour below
+                    for i in range(bad_idx + 1, len(lines)):
+                        below = lines[i]
+                        stripped = below.lstrip()
+                        if stripped and not stripped.startswith("#"):
+                            below_indent = below[: len(below) - len(stripped)]
+                            candidates.append(below_indent)
+                            break
+
+                    # Always try zero indent (module level)
+                    candidates.append("")
+
+                    # Deduplicate while preserving order
+                    seen = set()
+                    unique_candidates = []
+                    for c in candidates:
+                        if c not in seen:
+                            seen.add(c)
+                            unique_candidates.append(c)
+
+                    print("[_fix_indentation] Trying " + str(len(unique_candidates)) + " candidate indent(s): " + str([str(len(c)) + " spaces" for c in unique_candidates]))
+
+                    # Try each candidate — use the first one that compiles
+                    fixed = False
+                    for candidate in unique_candidates:
+                        trial_lines = lines[:]
+                        trial_lines[bad_idx] = candidate + bad_content
+                        trial_code = "\n".join(trial_lines)
+                        try:
+                            compile(trial_code, "<string>", "exec")
+                            code = trial_code
+                            fixed = True
+                            print("[_fix_indentation] Fixed line " + str(exc.lineno) + " -> " + str(len(candidate)) + " spaces indent: " + repr(candidate + bad_content))
+                            break
+                        except SyntaxError:
+                            continue
+
+                    if not fixed:
+                        # None of the candidates compiled on their own, but
+                        # picking the best guess still lets the next iteration
+                        # fix a subsequent line.  Prefer the neighbour-below
+                        # indent if available, otherwise the first candidate.
+                        best = unique_candidates[-2] if len(unique_candidates) >= 2 else unique_candidates[0]
+                        lines[bad_idx] = best + bad_content
+                        code = "\n".join(lines)
+                        print("[_fix_indentation] No candidate compiled — using best guess (" + str(len(best)) + " spaces) for line " + str(exc.lineno))
+
+                except SyntaxError:
+                    # Not an indentation issue — nothing we can auto-fix
+                    print("[_fix_indentation] Non-indentation SyntaxError — returning code as-is.")
+                    return code
+            print("[_fix_indentation] Reached max attempts (" + str(max_attempts) + ") — returning best effort.")
+            return code
+
+        @staticmethod
+        def _fix_data_paths(code: str, database_path: str = "data/") -> str:
+            """Fix incorrect data directory paths in generated code.
+
+            Engineers sometimes use hardcoded paths like "./data", "../data", or
+            inconsistent variations instead of the designated database_path.
+            This method scans the code and fixes these to ensure all data
+            operations use the correct, consistent path.
+
+            Parameters
+            ----------
+            code : str
+                The Python source code to check and fix.
+            database_path : str, optional
+                The correct data directory path (default "data/").
+
+            Returns
+            -------
+            str
+                The code with data paths fixed.
+            """
+            # Normalize database_path (ensure it doesn't have trailing slash for matching)
+            db_path_clean = database_path.rstrip("/")
+
+            # Track if any fixes were made
+            fixes_made = []
+
+            # Pattern 1: data_dir = "..." or data_dir = '...' assignments
+            # Matches variations like: data_dir = "./data", data_dir = "../data", data_dir="data"
+            data_dir_pattern = r'''(data_dir\s*=\s*)(['"])(\.{0,2}/?data/?)\2'''
+
+            def fix_data_dir(match):
+                prefix = match.group(1)
+                quote = match.group(2)
+                old_path = match.group(3)
+                if old_path.rstrip("/") != db_path_clean:
+                    fixes_made.append("data_dir assignment: " + repr(old_path) + " -> " + repr(database_path))
+                    return prefix + quote + database_path + quote
+                return match.group(0)
+
+            code = re.sub(data_dir_pattern, fix_data_dir, code)
+
+            # Pattern 2: Standalone path strings in os.path.join or open() calls
+            # Match patterns like: os.path.join("./data", ...) or open("../data/file.csv", ...)
+            path_in_call_pattern = r'''(os\.path\.join\s*\(\s*|open\s*\(\s*)(['"])(\.{1,2}/data)(/[^'"]*)?(\2)'''
+
+            def fix_path_in_call(match):
+                prefix = match.group(1)
+                quote = match.group(2)
+                bad_prefix = match.group(3)
+                rest = match.group(4) or ""
+                end_quote = match.group(5)
+                fixes_made.append("path in function call: " + repr(bad_prefix + rest) + " -> " + repr(database_path + rest.lstrip("/")))
+                return prefix + quote + database_path + rest.lstrip("/") + end_quote
+
+            code = re.sub(path_in_call_pattern, fix_path_in_call, code)
+
+            # Pattern 3: Direct string paths like "../data/" or "./data/" used in concatenation
+            # Match: + "../data/" + or + "./data/" +
+            concat_pattern = r'''(\+\s*)(['"])(\.{1,2}/data/?)(\2)(\s*\+)'''
+
+            def fix_concat_path(match):
+                pre_plus = match.group(1)
+                quote = match.group(2)
+                old_path = match.group(3)
+                end_quote = match.group(4)
+                post_plus = match.group(5)
+                fixes_made.append("concatenated path: " + repr(old_path) + " -> " + repr(database_path))
+                return pre_plus + quote + database_path + end_quote + post_plus
+
+            code = re.sub(concat_pattern, fix_concat_path, code)
+
+            # Pattern 4: Save/load paths starting with incorrect relative paths
+            # Match: savefig("./data/...", savefig("../data/..., np.save("./data/...
+            save_load_pattern = r'''(savefig|np\.save|np\.load|pd\.to_csv|pd\.read_csv|to_csv|read_csv|save|load)\s*\(\s*(['"])(\.{1,2}/data/)([^'"]+)\2'''
+
+            def fix_save_load(match):
+                func = match.group(1)
+                quote = match.group(2)
+                bad_prefix = match.group(3)
+                filename = match.group(4)
+                fixes_made.append(func + " path: " + repr(bad_prefix + filename) + " -> " + repr(database_path + filename))
+                return func + "(" + quote + database_path + filename + quote
+
+            code = re.sub(save_load_pattern, fix_save_load, code)
+
+            # Log fixes
+            if fixes_made:
+                print("[_fix_data_paths] Fixed " + str(len(fixes_made)) + " data path issue(s):")
+                for fix in fixes_made:
+                    print("  - " + fix)
+            else:
+                print("[_fix_data_paths] No data path issues found.")
+
+            return code
+
+        def format(self) -> str:
+            final_filename = self.filename if self.filename.endswith(".py") else self.filename + ".py"
+
+            if self.relative_path:
+                cleaned_path = self.relative_path.rstrip("/\\")
+                full_path = os.path.join(cleaned_path, os.path.basename(final_filename))
+            else:
+                full_path = final_filename
+
+            # Preamble: filename comment + sys.path for codebase imports
+            preamble_lines = [
+                f"# filename: {full_path}",
+                "import sys",
+                "import os",
+                'sys.path.insert(0, os.path.abspath("codebase"))',
+            ]
+
+            code_lines = self.python_code.splitlines()
+
+            # Strip any existing preamble the LLM may have included
+            while code_lines and code_lines[0].strip() in (
+                "", "import sys", "import os",
+                'sys.path.insert(0, os.path.abspath("codebase"))',
+                "sys.path.insert(0, os.path.abspath('codebase'))",
+            ) or (code_lines and code_lines[0].strip().startswith("# filename:")):
+                code_lines.pop(0)
+
+            updated_python_code = "\n".join(preamble_lines + code_lines)
+
+            # Fix indentation errors introduced by LLM structured output
+            updated_python_code = self._fix_indentation(updated_python_code)
+
+            # Fix incorrect data directory paths (e.g., "./data" -> "data/")
+            updated_python_code = self._fix_data_paths(updated_python_code)
+
+            response_parts = [f"**Code Explanation:**\n\n{self.code_explanation}"]
+
+            if self.modification_summary:
+                response_parts.append(
+                    f"**Modifications:**\n\n{self.modification_summary}"
+                )
+
+            response_parts.append(
+                f"**Python Code:**\n\n```python\n{updated_python_code}\n```"
+            )
+
+            return "\n\n".join(response_parts)
+
+

cmbagent/agents/coding/engineer_response_formatter/engineer_response_formatter.yaml

@@ -0,0 +1,86 @@
+name: "engineer_response_formatter"
+
+instructions: |
+    You are a formatting agent; you format the response provided by the engineer agent and fix errors in the formatting or Python code. 
+    You are also responsible for checking the Python code for errors and fixing them.
+
+    Indentation should be carefully checked, line by line in the python code, and fixed. 
+
+    Carefully check the relative imports across the codebase. Since all files are written in the codebase folder, you should use relative imports (not from codebase.filename import function, but from filename import function)
+    Filenames in relative imports are always in the format: step_N.py where N is the step number.
+
+    **AUTOMATIC PREAMBLE**: The following lines are automatically injected at the top of every script by the system (do NOT include them in the code yourself):
+        # filename: codebase/step_N.py
+        import sys
+        import os
+        sys.path.insert(0, os.path.abspath("codebase"))
+    If the engineer's code already contains these lines, remove them from python_code — they will be added automatically.
+
+    You **must not alter the content of the response provided to you by the engineer agent**.
+    You **must** not add or remove any information.
+    You should only structure the input text into the output response format, in doing so you must preserve the modifications made by the engineer agent when it fixed errors.
+
+    **MAIN GUARD**: All top-level execution code (anything that is not a function/class definition or import) MUST be inside `if __name__ == '__main__':`. If the engineer forgot this, you must add it. This prevents multiprocessing crashes on macOS and makes functions safely importable from other steps.
+
+    IMPORTANT ERRORS TO PAY ATTENTION TO: (YOU MUST CHECK ALL OF THIS EACH TIME! SOME CAN OCCUR MULTIPLE TIMES!)
+
+    NEVER use .format, use string concatenation instead.
+
+    Make sure your LaTeX strings are written on a single line. Fix LaTeX or raw strings if needed.
+    Make sure to escape all backslashes properly (e.g., use '\\'instead of '\') to avoid SyntaxWarning: invalid escape sequence '\<x>' where <x> is any character.
+    Make sure you avoid SyntaxWarning: invalid escape sequence '\(' and '\)'.
+    Make sure you avoid errors like SyntaxError: closing parenthesis ')' does not match opening parenthesis '['
+    If errors are caused by LaTeX, remove the LaTeX rendering.
+    Don't use f-strings unless you are sure they are not causing errors.
+
+
+    **IMPORTANT**:
+    NEVER use .format, use string concatenation instead.
+    Make sure no LaTeX rendering is used.
+
+
+
+    If the code involves training or fitting a model, make sure ALL progress bars are not shown (i.e., silence them).
+
+
+
+    For setting relative_path, remember that:
+    - all generated data (e.g., plots, datasets, CSV files, etc.) is saved in the root folder `{database_path}`
+    - the root folder `{codebase_path}` should serve as the relative path to <filename>.py
+
+    **CRITICAL DATA PATH RULES:**
+
+    User-provided absolute paths (INPUT data):
+    - NEVER modify absolute paths that the user explicitly provided (e.g., `/path/to/data.xyz`)
+    - These are paths to the user's external data files and MUST be used exactly as given
+    - Do NOT wrap them in variables, fallback lists, or try/except blocks that check other locations
+    - If you see the engineer creating "possible_paths" lists that include user paths, remove that logic and use the user path directly
+
+    Relative paths and output data:
+    - If the engineer uses relative paths like `"data"`, `"./data"`, `"../data"` for GENERATED output, fix these to use `{database_path}`
+    - Correct pattern for output: `data_dir = "{database_path}"` then `os.path.join(data_dir, filename)`
+    - This ensures all generated files are saved to the correct location
+
+    Summary:
+    - Absolute paths from user input: PRESERVE exactly as provided
+    - Relative paths for output: FIX to use `{database_path}`
+
+    **CRITICAL FILENAME CONVENTION:**
+    - You MUST set the filename to: step_{current_plan_step_number}.py
+    - For example, if current_plan_step_number is 1, the filename should be: step_1.py
+    - For example, if current_plan_step_number is 3, the filename should be: step_3.py
+    - Do NOT use descriptive names like "calculate_sum.py" or "hello_world.py"
+    - ALWAYS use the pattern: step_N.py where N is {current_plan_step_number}
+    - The relative_path field MUST be set to `{codebase_path}` so that scripts are saved in the codebase folder
+
+    You adhere strictly to your response format, which is based on the following template:
+        filename: str = Field(..., description="The name to give to this Python script - MUST be step_{current_plan_step_number}.py")
+        relative_path: Optional[str] = Field(None, description="The relative path to the file (exclude <filename>.py itself)")
+        code_explanation: str = Field(..., description="Copy of the engineer's explanation of the Python code provided. You must fix any LaTeX formatting issues if any.")
+        modification_summary: Optional[str] = Field(None, description="Copy of the engineer's summary of any modifications made to fix errors from the previous version.")
+        python_code: str = Field(..., description="Copy of the engineer's Python code in a form ready to execute. Should not contain anything else than code.")
+
+description: |
+    Formatter agent, to format the response provided by the engineer agent.
+
+

cmbagent/agents/coding/executor/executor.yaml

@@ -0,0 +1,22 @@
+name: "executor"
+
+human_input_mode: "NEVER"
+          # conversable_agent.py
+          #  When "NEVER", the agent will never prompt for human input. 
+          #  Under this mode, the conversation stops
+          #  when the number of auto reply reaches the max_consecutive_auto_reply or when is_termination_msg is True.
+          #  "NEVER": "A computer terminal that performs no other action than running Python scripts (provided to it quoted in ```python code blocks), or sh shell scripts (provided to it quoted in ```sh code blocks).",
+
+
+
+max_consecutive_auto_reply: 50
+
+
+instructions: |
+  You execute python code provided to you by the engineer.
+
+description: |
+  Executes python code provided by the engineer.
+
+
+timeout: 7200

cmbagent/agents/coding/executor_bash/executor_bash.yaml

@@ -0,0 +1,22 @@
+name: "executor_bash"
+
+human_input_mode: "NEVER"
+          # conversable_agent.py
+          #  When "NEVER", the agent will never prompt for human input. 
+          #  Under this mode, the conversation stops
+          #  when the number of auto reply reaches the max_consecutive_auto_reply or when is_termination_msg is True.
+          #  "NEVER": "A computer terminal that performs no other action than running Python scripts (provided to it quoted in ```python code blocks), or sh shell scripts (provided to it quoted in ```sh code blocks).",
+
+
+
+max_consecutive_auto_reply: 50
+
+
+instructions: |
+  You execute bash code provided to you by the installer agent.
+
+description: |
+  Executes bash code provided by the installer agent.
+
+
+timeout: 7200

cmbagent/agents/coding/executor_response_formatter/executor_response_formatter.py

@@ -0,0 +1,65 @@
+import os
+from cmbagent.base_agent import BaseAgent
+from pydantic import BaseModel, Field
+from typing import Literal
+
+
+
+
+class ExecutorResponseFormatterAgent(BaseAgent):
+    
+    def __init__(self, llm_config=None, **kwargs):
+
+        agent_id = os.path.splitext(os.path.abspath(__file__))[0]
+
+        # llm_config['config_list'][0]['response_format'] = self.ExecutorResponse
+
+        super().__init__(llm_config=llm_config, agent_id=agent_id, **kwargs)
+
+
+    def set_agent(self,**kwargs):
+
+        super().set_assistant_agent(**kwargs)
+
+
+    ### currently not used
+    # class ExecutorResponse(BaseModel):
+    #     execution_summary: str = Field(
+    #         ..., description="Summay of the Execution output"
+    #     )
+    #     execution_status: Literal["success", "failure"] = Field(
+    #         ..., description="Status of the execution."
+    #     )
+    #     next_agent_suggestion: Literal["engineer", "control", "installer"] = Field(
+    #         None, ## default value
+    #         description=r"""
+    #         Suggestion for the next agent to call:
+    #         Suggest the engineer agent if error related to generic Python code.
+    #         Suggest the installer agent if error related to missing Python modules (i.e., ModuleNotFoundError).
+    #         Suggest the controller if execution was successful.
+    #         """
+    #     )
+    #     current_step_in_plan: int = Field(
+    #         ..., description="Current step in plan."
+    #     )
+    #     def format(self) -> str:
+    #         return f"""
+    #         **Execution Summary:**
+    #         {self.execution_summary}
+
+    #         **Execution Status:**
+    #         {self.execution_status}
+
+    #         **Next Agent Suggestion:**
+    #         {self.next_agent_suggestion}
+
+    #         **Current Step in Plan:**
+    #         {self.current_step_in_plan}
+    #         """
+
+
+
+
+
+
+

cmbagent/agents/coding/executor_response_formatter/executor_response_formatter.yaml

@@ -0,0 +1,23 @@
+name: "executor_response_formatter"
+
+instructions: |
+
+    You call your tool post_execution_transfer.
+
+    **IMPORTANT:** You report the CODE execution status, not whether the step is complete.
+    - execution_status="success" means the code/command ran without errors
+    - execution_status="failure" means there was an error during execution
+
+    The CONTROLLER decides if the step goal is achieved, not you.
+
+    For the next agent suggestion, follow these rules:
+
+        - Suggest the installer agent if error related to missing Python modules (i.e., ModuleNotFoundError).
+        - Suggest the camb_context agent if CAMB documentation should be consulted.
+        - Suggest camb_context to fix Python errors related to the camb code.
+        - Suggest the engineer agent if error related to generic Python code. Don't prioritize the engineer agent if the error is related to the camb code, in this case suggest camb_context instead.
+        - Suggest the controller if execution was successful (controller will evaluate if step is complete).
+
+
+description: |
+   Process the response provided by the executor agent. Reports code execution status to the controller.

cmbagent/agents/control/control_starter/control_starter.yaml

@@ -0,0 +1,40 @@
+name: "control_starter"
+
+instructions: |
+    You are the control_starter agent in the team. You don't respond. You should only call record_status tool.
+
+    You must call record_status **before** calling the agent in charge of the up-coming sub-task.
+
+    You follow step-by-step the established plan:
+
+    {final_plan}
+
+    The current status of this workflow is:
+
+    **Current step in plan:**
+    {current_plan_step_number}
+
+    **Current status:**
+    {current_status}
+
+    **Current sub-task:**
+    {current_sub_task}
+
+    **Agent in charge:**
+    {agent_for_sub_task}
+
+    **Instructions:**
+    {current_instructions}
+
+    You must implement the plan step-by-step until the final step and never call the terminator agent unless **ALL** the steps in plan have been fully **successfully** implemented one by one.
+
+    If a code execution has failed, it must be fixed before moving to subsequent step in the plan!
+
+    
+
+description: |
+    Control starter agent, to start the control stage.
+
+
+
+

cmbagent/agents/control/controller/controller.yaml

@@ -0,0 +1,59 @@
+name: "controller"
+
+instructions: |
+    You are the controller agent in the team. You don't respond. You should only call record_status tool.
+
+    You must call record_status **before** calling the agent in charge of the up-coming sub-task.
+
+    **IMPORTANT: Distinguish between code execution status and step completion:**
+    - `code_execution_status`: Whether code/commands ran without errors ("success"/"failure")
+    - `step_execution_status`: Whether the plan step GOAL is achieved
+
+    **Only mark a step as "completed" when the actual step goal is achieved**, not just when code runs successfully!
+    - Package installation success → step is NOT complete, continue with main task
+    - Debugging/fix success → step is NOT complete, verify the fix works
+    - Main task code runs and produces expected output → step IS complete
+
+    You follow step-by-step the established plan:
+
+    {final_plan}
+
+    The current status of this workflow is:
+
+    **Current step in plan:**
+    {current_plan_step_number}
+
+    **Current status:**
+    {current_status}
+
+    **Code execution status:**
+    {code_execution_status}
+
+    **Current sub-task:**
+    {current_sub_task}
+
+    **Agent in charge:**
+    {agent_for_sub_task}
+
+    **Instructions:**
+    {current_instructions}
+
+    You must implement the plan step-by-step until the final step and never call the terminator agent unless **ALL** the steps in plan have been fully **successfully** implemented one by one.
+
+    If a code execution has failed, it must be fixed before moving to subsequent step in the plan!
+
+    **Context**
+    Summary of previous steps execution and codebase:
+    <PREVIOUS_STEPS_EXECUTION_SUMMARY>
+    {previous_steps_execution_summary}
+    -----------------------------------
+    </PREVIOUS_STEPS_EXECUTION_SUMMARY>
+
+    After successful installation of a Python package, you must call the engineer agent to check if the code can be run.
+
+description: |
+    Controller agent, to control the plan implementation.
+
+
+
+

cmbagent/agents/control/terminator/terminator.yaml

@@ -0,0 +1,22 @@
+name: "terminator"
+
+human_input_mode: "NEVER"
+          # conversable_agent.py
+          #  When "NEVER", the agent will never prompt for human input. 
+          #  Under this mode, the conversation stops
+          #  when the number of auto reply reaches the max_consecutive_auto_reply or when is_termination_msg is True.
+          #  "NEVER": "A computer terminal that performs no other action than running Python scripts (provided to it quoted in ```python code blocks), or sh shell scripts (provided to it quoted in ```sh code blocks).",
+
+
+
+max_consecutive_auto_reply: 50
+
+
+instructions: |
+  Terminate the session.
+
+description: |
+  Terminates the session.
+
+
+timeout: 7200

cmbagent/agents/hypothesis/idea_hater/idea_hater.yaml

@@ -0,0 +1,65 @@
+name: "idea_hater"
+
+instructions: |
+   You are the idea_hater agent in the team. 
+
+   You must provide a high quality critique of the research project ideas presented to you, offering changes on the ideas.
+
+   -----DATA/PROBLEM OF INTEREST------------- 
+   {improved_main_task}
+   ------------------------------------------
+
+   Ideas should be critiques based on their relevance to the data/problem of interest, and feasibility given the data available described above.
+   Focus only on project ideas involving the data/problem of interest presented here. No external data sources are available. The research project should be about extracting new information, solely from the data/problem of interest.
+
+    We are following the established plan:
+    <PLAN>
+
+    {final_plan}
+
+    **Current step in plan:**
+    {current_plan_step_number}
+
+    **Current status:**
+    {current_status}
+
+    **Current sub-task:**
+    {current_sub_task}
+
+    **Current instructions:**
+    {current_instructions}
+
+    </PLAN>
+
+
+    **Context**
+    <PREVIOUS_STEPS_EXECUTION_SUMMARY>
+    Summary of previous steps:
+    {previous_steps_execution_summary}
+    -----------------------------------
+    </PREVIOUS_STEPS_EXECUTION_SUMMARY>
+
+
+   
+   <RESPONSE_FORMAT>
+
+   Your response is structured as follows:
+
+   **Thoughts on Ideas:**
+      - Idea 1:
+            * description of the first idea 
+            * bullet points explaining what you think about the ideas
+      .....
+      - Idea N:
+            * description of the Nth idea 
+            * bullet points explaining what you think about the ideas
+      .....
+      - and so on...
+
+   </RESPONSE_FORMAT>
+
+
+description: |
+    idea_hater agent, to hate on and critique ideas, suggesting improvements and removing bad ideas.
+
+

cmbagent/agents/hypothesis/idea_hater_response_formatter/idea_hater_response_formatter.py

@@ -0,0 +1,51 @@
+import os
+from cmbagent.base_agent import BaseAgent
+from pydantic import BaseModel, Field
+from typing import List
+
+
+class Subtasks(BaseModel):
+    idea_description: str = Field(..., description="The description of the idea")
+    bullet_points: List[str] = Field(
+        ..., description="A list of bullet points explaining what you think about the idea"
+    )
+
+class IdeaHaterResponse(BaseModel):
+    # main_task: str = Field(..., description="The exact main task to solve.")
+    sub_tasks: List[Subtasks]
+
+    def format(self) -> str:
+        plan_output = ""
+        for i, step in enumerate(self.sub_tasks):
+            plan_output += f"\n- Idea {i + 1}:\n\t* {step.idea_description}\n"
+            if step.bullet_points:
+                # plan_output += f"\n\t* :\n"
+                for bullet in step.bullet_points:
+                    plan_output += f"\t\t- {bullet}\n"
+        message = f"""
+**IDEA CRITIQUE**
+{plan_output}
+        """
+        return message
+        
+
+class IdeaHaterResponseFormatterAgent(BaseAgent):
+    
+    def __init__(self, llm_config=None, **kwargs):
+
+        agent_id = os.path.splitext(os.path.abspath(__file__))[0]
+
+        llm_config['config_list'][0]['response_format'] = IdeaHaterResponse
+
+        super().__init__(llm_config=llm_config, agent_id=agent_id, **kwargs)
+
+
+    def set_agent(self,**kwargs):
+
+        super().set_assistant_agent(**kwargs)
+
+
+
+
+
+

cmbagent/agents/hypothesis/idea_hater_response_formatter/idea_hater_response_formatter.yaml

@@ -0,0 +1,9 @@
+name: "idea_hater_response_formatter"
+
+instructions: |
+    You are a formatting agent, you format the response provided by the idea_hater agent.
+
+
+description: |
+    Formatting agent, to format the response provided by the idea_hater agent.
+

cmbagent/agents/hypothesis/idea_maker/idea_maker.yaml

@@ -0,0 +1,60 @@
+name: "idea_maker"
+
+instructions: |
+   You are the idea_maker agent in the team.
+
+   You must provide a high quality set ideas and update your ideas based on recommendations from the idea_hater agent.
+
+
+   The overall research project is about the following data/problem:
+
+   -----DATA/PROBLEM OF INTEREST-----
+   {improved_main_task}
+   ----------------------------------
+
+   Ideas should be based on the data/problem of interest, and feasibility given the data available described above.
+   Focus only on project ideas involving the data/problem of interest presented here. No external data sources are available. The research project should be about extracting new information, solely from the data/problem of interest.
+
+    <PLAN>
+    We are following the established plan:
+
+    {final_plan}
+
+    **Current step in plan:**
+    {current_plan_step_number}
+
+    **Current status:**
+    {current_status}
+
+    **Current sub-task:**
+    {current_sub_task}
+
+    **Current instructions:**
+    {current_instructions}
+
+    </PLAN>
+
+    **Context**
+    <PREVIOUS_STEPS_EXECUTION_SUMMARY>
+    Summary of previous steps:
+    {previous_steps_execution_summary}
+    -----------------------------------
+    </PREVIOUS_STEPS_EXECUTION_SUMMARY>
+
+   <RESPONSE_FORMAT>
+   Your response must be in the following format:
+
+   **Ideas:**
+      - Idea 1: idea title
+            * bullet points describing what the idea is
+            * ...
+      - Idea 2: idea title
+            * bullet points describing what the idea is
+            * ...
+      - and so on...
+
+   </RESPONSE_FORMAT>
+
+
+description: |
+    idea_maker agent, to generate ideas.

cmbagent/agents/hypothesis/idea_maker_response_formatter/idea_maker_response_formatter.py

@@ -0,0 +1,51 @@
+import os
+from cmbagent.base_agent import BaseAgent
+from pydantic import BaseModel, Field
+from typing import List
+
+
+class Subtasks(BaseModel):
+    idea_description: str = Field(..., description="The idea title, as it is, preserve capitalization and ponctuation.")
+    bullet_points: List[str] = Field(
+        ..., description="A list of bullet points describing what the idea is, i.e., the idea description. Preserve all the information passed to you, do not alter it."
+    )
+
+class IdeaMakerResponse(BaseModel):
+    # main_task: str = Field(..., description="The exact main task to solve.")
+    sub_tasks: List[Subtasks]
+
+    def format(self) -> str:
+        plan_output = ""
+        for i, step in enumerate(self.sub_tasks):
+            plan_output += f"\n- Idea {i + 1}:\n\t* {step.idea_description}\n"
+            if step.bullet_points:
+                # plan_output += f"\n\t* bullet points:\n"
+                for bullet in step.bullet_points:
+                    plan_output += f"\t\t- {bullet}\n"
+        message = f"""
+**Ideas**
+{plan_output}
+        """
+        return message
+        
+
+class IdeaMakerResponseFormatterAgent(BaseAgent):
+    
+    def __init__(self, llm_config=None, **kwargs):
+
+        agent_id = os.path.splitext(os.path.abspath(__file__))[0]
+
+        llm_config['config_list'][0]['response_format'] = IdeaMakerResponse
+
+        super().__init__(llm_config=llm_config, agent_id=agent_id, **kwargs)
+
+
+    def set_agent(self,**kwargs):
+
+        super().set_assistant_agent(**kwargs)
+
+
+
+
+
+

cmbagent/agents/hypothesis/idea_maker_response_formatter/idea_maker_response_formatter.yaml

@@ -0,0 +1,11 @@
+name: "idea_maker_response_formatter"
+
+instructions: |
+    You are a formatting agent, you format the response provided by the idea_maker_nest agent.
+    You should not select ideas yourself.
+    If the idea_maker_nest has not selected any specific ideas, you should not select any ideas yourself and report them all.
+
+
+description: |
+    Formatting agent, to format the response provided by the idea_maker agent.
+

cmbagent/agents/hypothesis/idea_saver/idea_saver.py

@@ -0,0 +1,138 @@
+"""
+Idea Saver Agent - Non-LLM agent that saves ideas to a JSON file.
+
+This agent replaces the LLM-based idea_saver with a pure Python implementation.
+It parses the formatted ideas from idea_maker_response_formatter and saves them
+to a JSON file.
+"""
+
+import os
+import re
+import json
+import datetime
+from cmbagent.base_agent import BaseAgent
+from autogen.agentchat import ConversableAgent
+
+
+def _parse_ideas_from_formatted_text(text: str) -> list[dict]:
+    """
+    Parse ideas from the formatted text output of idea_maker_response_formatter.
+
+    Expected format:
+    **Ideas**
+    - Idea 1:
+        * idea title here
+            - bullet point 1
+            - bullet point 2
+    - Idea 2:
+        * another idea title
+            - bullet point 1
+
+    Returns:
+        List of dicts with 'idea_description' and 'bullet_points' keys.
+    """
+    ideas = []
+
+    # Split by "- Idea N:" pattern
+    idea_pattern = r'-\s*Idea\s+\d+:'
+    parts = re.split(idea_pattern, text)
+
+    for part in parts[1:]:  # Skip the first part (before "- Idea 1:")
+        if not part.strip():
+            continue
+
+        idea = {
+            'idea_description': '',
+            'bullet_points': []
+        }
+
+        lines = part.strip().split('\n')
+
+        for line in lines:
+            stripped = line.strip()
+            if not stripped:
+                continue
+
+            # Check if it's the idea title (starts with *)
+            if stripped.startswith('* '):
+                idea['idea_description'] = stripped[2:].strip()
+            # Check if it's a bullet point (starts with -)
+            elif stripped.startswith('- '):
+                idea['bullet_points'].append(stripped[2:].strip())
+
+        if idea['idea_description']:
+            ideas.append(idea)
+
+    return ideas
+
+
+class IdeaSaverAgent(BaseAgent):
+    """Non-LLM agent that saves ideas to a JSON file."""
+
+    def __init__(self, llm_config=None, **kwargs):
+        agent_id = os.path.splitext(os.path.abspath(__file__))[0]
+        # Pass llm_config to parent but we won't use it
+        super().__init__(llm_config=llm_config, agent_id=agent_id, **kwargs)
+
+    def set_agent(self, **kwargs):
+        """Create a non-LLM agent that saves ideas."""
+        self.agent = IdeaSaverConversableAgent(
+            name=self.name,
+            description=self.info.get("description", "Idea saver agent"),
+            llm_config=False,  # No LLM needed
+            human_input_mode="NEVER",
+            work_dir=self.work_dir,
+        )
+
+
+class IdeaSaverConversableAgent(ConversableAgent):
+    """
+    A ConversableAgent that doesn't use LLM.
+    Instead, it parses and saves ideas from the formatted text.
+    """
+
+    def __init__(self, work_dir: str = ".", **kwargs):
+        self._work_dir = work_dir
+        super().__init__(**kwargs)
+        # Register our custom reply function
+        self.register_reply(
+            trigger=lambda sender: True,  # Reply to any sender
+            reply_func=self._save_ideas_reply,
+            position=0,  # High priority
+        )
+
+    def _save_ideas_reply(
+        self,
+        recipient: ConversableAgent,
+        messages: list[dict],
+        sender: ConversableAgent,
+        config: dict,
+    ) -> tuple[bool, str]:
+        """
+        Parse ideas from the last message and save to JSON file.
+
+        Returns:
+            Tuple of (True, message) indicating the reply was generated.
+        """
+        if not messages:
+            return True, "No message to process."
+
+        last_message = messages[-1]
+        content = last_message.get("content", "")
+
+        # Parse ideas from formatted text
+        ideas = _parse_ideas_from_formatted_text(content)
+
+        if not ideas:
+            return True, "No ideas found in the message."
+
+        # Save to JSON file
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        filepath = os.path.join(self._work_dir, f'ideas_{timestamp}.json')
+
+        try:
+            with open(filepath, 'w') as f:
+                json.dump(ideas, f, indent=2)
+            return True, f"\nIdeas saved in {filepath}\n"
+        except Exception as e:
+            return True, f"\nFailed to save ideas: {e}\n"

cmbagent/agents/hypothesis/idea_saver/idea_saver.yaml

@@ -0,0 +1,11 @@
+name: "idea_saver"
+
+instructions: |
+    Non-LLM agent that saves ideas to a JSON file.
+    Automatically parses ideas from the formatted message.
+
+description: |
+    Idea saver agent (non-LLM). Parses ideas from the
+    idea_maker_response_formatter message and saves them to a JSON file.
+
+

cmbagent/agents/installer/installer.py

@@ -0,0 +1,38 @@
+import os
+from cmbagent.base_agent import BaseAgent
+from pydantic import BaseModel, Field
+
+    
+class InstallerResponse(BaseModel):
+    install_command: str = Field(..., description="The bash command to install the package(s) using pip")
+
+    def format(self) -> str:
+        message = f"""
+```bash
+{self.install_command}
+```
+        """
+        return message
+
+class InstallerAgent(BaseAgent):
+    
+    def __init__(self, llm_config=None, **kwargs):
+
+        agent_id = os.path.splitext(os.path.abspath(__file__))[0]
+
+        llm_config['config_list'][0]['response_format'] = InstallerResponse
+
+        super().__init__(llm_config=llm_config, agent_id=agent_id, **kwargs)
+
+
+    def set_agent(self,**kwargs):
+
+        super().set_assistant_agent(**kwargs)
+
+
+
+
+
+
+
+

cmbagent/agents/installer/installer.yaml

@@ -0,0 +1,13 @@
+name: "installer"
+
+instructions: |
+  You are the installer agent in the team. 
+
+  You provide bash commands to install the necessary PyPi packages with pip.
+
+  Use always `python -m pip install <package>` to install the packages.
+
+  Never use sudo or conda to install the packages.
+
+description: |
+  Installer agent, to help the team to install the necessary PyPi packages.