diff --git a/.codeboarding/Background Task Processing.md b/.codeboarding/Background Task Processing.md
new file mode 100644
index 0000000..30ab36a
--- /dev/null
+++ b/.codeboarding/Background Task Processing.md
@@ -0,0 +1,100 @@
+```mermaid
+graph LR
+ HumanizationTasks["HumanizationTasks"]
+ HumannessCore["HumannessCore"]
+ HumanizationAlgorithms["HumanizationAlgorithms"]
+ Scheduler["Scheduler"]
+ CommonWebStats["CommonWebStats"]
+ Scheduler -- "manages" --> HumanizationTasks
+ HumanizationTasks -- "utilizes" --> HumannessCore
+ HumanizationTasks -- "applies" --> HumanizationAlgorithms
+ CommonWebStats -- "monitors" --> HumanizationTasks
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+The Background Task Processing subsystem is responsible for asynchronously executing long-running and computationally intensive tasks, primarily related to antibody humanization and humanness calculations. It leverages a scheduler, such as Celery, to offload these operations from the main application thread, thereby ensuring the responsiveness of the web interface and efficient resource utilization. The core tasks involve applying humanization algorithms and calculating humanness metrics, with results being managed and monitored for reporting and analysis.
+
+### HumanizationTasks
+Manages the asynchronous execution and result handling for antibody humanization and humanness evaluation tasks. It defines the data structures for task results and errors and orchestrates the application of humanization algorithms and humanness calculations.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.web.tasks:HumanizeAntibodyTaskError` (17:20)
+- `biophi.humanization.web.tasks:HumanizeAntibodyTaskResult` (24:119)
+- `biophi.humanization.web.tasks:humanize_antibody_task` (123:171)
+- `biophi.humanization.web.tasks:mutate_humanized_antibody_task` (175:205)
+- `biophi.humanization.web.tasks:HumannessTaskError` (208:211)
+- `biophi.humanization.web.tasks:HumannessTaskResult` (215:284)
+- `biophi.humanization.web.tasks:humanness_task` (287:312)
+
+
+### HumannessCore
+Provides the core logic and data models for calculating and representing antibody and chain humanness, including OASis-based metrics and germline content.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.methods.humanness:OASisParams` (24:34)
+- `biophi.humanization.methods.humanness:PeptideHumanness` (38:56)
+- `biophi.humanization.methods.humanness:ChainHumanness` (60:195)
+- `biophi.humanization.methods.humanness:AntibodyHumanness` (199:255)
+- `biophi.humanization.methods.humanness:get_antibody_humanness` (273:277)
+- `biophi.humanization.methods.humanness:get_chain_humanness` (319:343)
+- `biophi.humanization.methods.humanness:get_oasis_percentile` (full file reference)
+- `biophi.humanization.methods.humanness:get_germline_family_residue_frequency` (full file reference)
+- `biophi.humanization.methods.humanness:get_chain_type_residue_frequency` (full file reference)
+
+
+### HumanizationAlgorithms
+Implements various antibody humanization methods, including Sapiens (deep learning-based) and CDR Grafting, and defines parameters for these methods.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.methods.humanization:HumanizationParams` (14:20)
+- `biophi.humanization.methods.humanization:SapiensHumanizationParams` (24:38)
+- `biophi.humanization.methods.humanization:CDRGraftingHumanizationParams` (42:60)
+- `biophi.humanization.methods.humanization:ManualHumanizationParams` (64:68)
+- `biophi.humanization.methods.humanization:ChainHumanization` (78:117)
+- `biophi.humanization.methods.humanization:AntibodyHumanization` (121:155)
+- `biophi.humanization.methods.humanization:humanize_antibody` (158:162)
+- `biophi.humanization.methods.humanization:humanize_chain` (165:175)
+- `biophi.humanization.methods.humanization:cdr_grafting_humanize_chain` (178:204)
+- `biophi.humanization.methods.humanization:sapiens_humanize_chain` (207:246)
+- `biophi.humanization.methods.humanization:sapiens_predict_chain` (249:257)
+
+
+### Scheduler
+Provides an abstraction for scheduling and managing asynchronous tasks, with concrete implementations for distributed (Celery) and in-memory schedulers.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.utils.scheduler:Scheduler` (12:44)
+- `biophi.common.utils.scheduler:CeleryScheduler` (47:90)
+- `biophi.common.utils.scheduler:SimpleInMemoryScheduler` (93:136)
+- `biophi.common.utils.scheduler:NotInitializedScheduler` (139:165)
+- `biophi.common.utils.scheduler:use_scheduler` (179:186)
+- `biophi.common.utils.scheduler:TaskNotFoundError` (8:9)
+
+
+### CommonWebStats
+Contains utilities for Celery task integration, logging task results, and general web-related functionalities, including monitoring task outcomes and submissions.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.web.tasks:celery` (full file reference)
+- `biophi.common.web.tasks:log_task_postrun` (39:43)
+- `biophi.common.web.tasks:log_task_failure` (47:50)
+- `biophi.common.utils.stats:log_task_result` (45:54)
+- `biophi.common.utils.stats:log_submission` (25:42)
+- `biophi.common.utils.stats:log_access` (57:67)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Common Utilities.md b/.codeboarding/Common Utilities.md
new file mode 100644
index 0000000..e805bcc
--- /dev/null
+++ b/.codeboarding/Common Utilities.md
@@ -0,0 +1,192 @@
+```mermaid
+graph LR
+ CLI_Core["CLI Core"]
+ Formatting_Utilities["Formatting Utilities"]
+ Task_Scheduling["Task Scheduling"]
+ Statistics_Logging["Statistics & Logging"]
+ Antibody_Data_IO["Antibody Data IO"]
+ Sequence_Utilities["Sequence Utilities"]
+ Common_Web_Interface["Common Web Interface"]
+ Humanization_CLI["Humanization CLI"]
+ Humanization_Web_Interface["Humanization Web Interface"]
+ Humanization_Core_Logic["Humanization Core Logic"]
+ CLI_Core -- "initializes with" --> Task_Scheduling
+ CLI_Core -- "displays using" --> Formatting_Utilities
+ Antibody_Data_IO -- "logs data via" --> Statistics_Logging
+ Antibody_Data_IO -- "validates sequences using" --> Sequence_Utilities
+ Common_Web_Interface -- "retrieves statistics from" --> Statistics_Logging
+ Common_Web_Interface -- "logs task results via" --> Statistics_Logging
+ Humanization_CLI -- "processes input using" --> Antibody_Data_IO
+ Humanization_CLI -- "iterates sequences using" --> Sequence_Utilities
+ Humanization_CLI -- "performs humanization with" --> Humanization_Core_Logic
+ Humanization_Web_Interface -- "handles input via" --> Antibody_Data_IO
+ Humanization_Web_Interface -- "exports results using" --> Antibody_Data_IO
+ Humanization_Web_Interface -- "performs humanization with" --> Humanization_Core_Logic
+ Humanization_Core_Logic -- "generates filenames using" --> Formatting_Utilities
+ Humanization_Core_Logic -- "utilizes" --> Sequence_Utilities
+ Task_Scheduling -- "manages tasks for" --> CLI_Core
+ Task_Scheduling -- "manages tasks for" --> Common_Web_Interface
+ Statistics_Logging -- "receives data from" --> Antibody_Data_IO
+ Statistics_Logging -- "provides data to" --> Common_Web_Interface
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+Provides foundational utilities for input/output operations, including parsing antibody files (FASTA, PDB), handling sequence data, and managing data structures. It also offers general system utilities such as logging, statistics tracking, and text formatting, supporting robust data handling, monitoring, and consistent information presentation across the application.
+
+### CLI Core
+Handles the main command-line interface operations, including web interface initialization and general CLI output formatting.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.cli.web:web` (10:21)
+- `biophi.common.cli.main.MainGroup:__call__` (9:22)
+
+
+### Formatting Utilities
+Provides utility functions for formatting output, such as displaying logos, spacers, and generating valid filenames.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.utils.formatting.logo` (11:24)
+- `biophi.common.utils.formatting.spacer` (7:8)
+- `biophi.common.utils.formatting.get_valid_filename` (57:59)
+- `biophi.common.utils.formatting:human_size` (62:64)
+
+
+### Task Scheduling
+Manages the scheduling and retrieval of asynchronous tasks, supporting both Celery and in-memory implementations. It also defines exceptions for task management.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.utils.scheduler.use_scheduler` (179:186)
+- `biophi.common.utils.scheduler.CeleryScheduler` (47:90)
+- `biophi.common.utils.scheduler.SimpleInMemoryScheduler` (93:136)
+- `biophi.common.utils.scheduler.NotInitializedScheduler` (139:165)
+- `biophi.common.utils.scheduler.TaskNotFoundError` (8:9)
+
+
+### Statistics & Logging
+Responsible for collecting and logging various application statistics, including submissions, task results, and access information.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.utils.stats:get_stats` (13:22)
+- `biophi.common.utils.stats:log_submission` (25:42)
+- `biophi.common.utils.stats:log_task_result` (45:54)
+- `biophi.common.utils.stats:log_access` (57:67)
+- `biophi.common.utils.stats:log_data` (70:99)
+- `biophi.common.utils.stats.get_engine` (105:115)
+
+
+### Antibody Data IO
+Handles the input and output operations related to antibody data, including parsing PDB files, managing antibody input objects, and reading/writing various file formats.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.utils.io.AntibodyPDB` (27:54)
+- `biophi.common.utils.io.AntibodyInput` (58:109)
+- `biophi.common.utils.io:read_antibody_input_request` (112:167)
+- `biophi.common.utils.io:pair_antibody_records` (212:254)
+- `biophi.common.utils.io:parse_antibody_pdb_ids` (257:266)
+- `biophi.common.utils.io:parse_antibody_inputs` (269:291)
+- `biophi.common.utils.io:parse_antibody_files` (307:345)
+- `biophi.common.utils.io:send_fasta` (382:386)
+- `biophi.common.utils.io:write_sheets` (463:471)
+- `biophi.common.utils.io:send_excel` (474:486)
+- `biophi.common.utils.io.convert_pdb_positions` (170:178)
+- `biophi.common.utils.io.clean_antibody_name` (201:209)
+- `biophi.common.utils.io.read_file_contents` (294:304)
+- `biophi.common.utils.io.clean_extension` (181:198)
+- `biophi.common.utils.io.shorten_sheet_names` (389:411)
+- `biophi.common.utils.io.sanitize_excel_sheet_name` (489:495)
+- `biophi.common.utils.io.write_sheet` (414:460)
+- `biophi.common.utils.io.send_text` (366:379)
+
+
+### Sequence Utilities
+Provides general utility functions for sequence manipulation and validation, such as checking for valid amino acid sequences, downloading PDBs, and parsing FASTA files.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.utils.seq.is_valid_amino_acid_sequence` (27:28)
+- `biophi.common.utils.seq.download_pdb` (86:87)
+- `biophi.common.utils.seq.looks_like_antibody_heavy_chain` (90:100)
+- `biophi.common.utils.seq.sanitize_sequence` (18:24)
+- `biophi.common.utils.seq.looks_like_dna` (106:109)
+- `biophi.common.utils.seq.parse_plaintext_records` (31:40)
+- `biophi.common.utils.seq:iterate_single_fasta` (52:71)
+- `biophi.common.utils.seq:iterate_fasta` (74:83)
+- `biophi.common.utils.seq:validate_dna` (127:133)
+- `biophi.common.utils.seq:validate_protein` (136:144)
+- `biophi.common.utils.seq.iterate_fasta_index` (43:49)
+- `biophi.common.utils.seq.looks_like_protein` (121:124)
+
+
+### Common Web Interface
+Contains the web views and background tasks common to the BioPhi application, including statistics display and task logging.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.web.views:stats` (91:101)
+- `biophi.common.web.tasks:log_task_postrun` (39:43)
+- `biophi.common.web.tasks:log_task_failure` (47:50)
+
+
+### Humanization CLI
+Implements the command-line interface for antibody humanization functionalities, including OASIS and Sapiens methods.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.cli.oasis:oasis` (19:96)
+- `biophi.humanization.cli.sapiens:sapiens` (33:124)
+- `biophi.humanization.cli.sapiens:sapiens_scores_only` (140:183)
+- `biophi.humanization.cli.sapiens:sapiens_fasta_only` (186:212)
+- `biophi.humanization.cli.sapiens:sapiens_full` (215:281)
+
+
+### Humanization Web Interface
+Provides the web views for antibody humanization, handling input requests, and exporting results in various formats.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.web.views:humanize_post` (97:160)
+- `biophi.humanization.web.views:humanize_detail_export_humanized_fasta` (222:229)
+- `biophi.humanization.web.views:humanize_detail_export_alignment` (233:239)
+- `biophi.humanization.web.views:humanize_detail_export_oasis_table` (243:252)
+- `biophi.humanization.web.views:humanize_batch_export_humanized_fasta` (256:260)
+- `biophi.humanization.web.views:humanize_batch_export_alignments` (264:269)
+- `biophi.humanization.web.views:humanize_batch_export_table` (273:281)
+- `biophi.humanization.web.views:humanness_post` (333:361)
+- `biophi.humanization.web.views:humanness_export_oasis_table` (411:416)
+- `biophi.humanization.web.views:humanness_detail_export_oasis_table` (420:427)
+
+
+### Humanization Core Logic
+Contains the core methods and statistical models for calculating humanness scores and performing humanization, including CDR grafting parameters.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.methods.humanness.ChainHumanness:get_oasis_percentile` (92:97)
+- `biophi.humanization.methods.humanness.AntibodyHumanness:get_oasis_percentile` (206:211)
+- `biophi.humanization.methods.humanness:get_chain_humanness` (319:343)
+- `biophi.humanization.methods.stats.get_oasis_percentile` (full file reference)
+- `biophi.humanization.methods.stats.get_germline_family_residue_frequency` (full file reference)
+- `biophi.humanization.methods.stats.get_chain_type_residue_frequency` (full file reference)
+- `biophi.humanization.methods.humanization.CDRGraftingHumanizationParams:get_export_name` (49:60)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Core Humanization Logic.md b/.codeboarding/Core Humanization Logic.md
new file mode 100644
index 0000000..1145755
--- /dev/null
+++ b/.codeboarding/Core Humanization Logic.md
@@ -0,0 +1,117 @@
+```mermaid
+graph LR
+ CLI_Interface["CLI Interface"]
+ Web_Interface["Web Interface"]
+ Humanization_Task_Management["Humanization Task Management"]
+ Core_Humanization_Logic["Core Humanization Logic"]
+ Humanness_Scoring["Humanness Scoring"]
+ Utility_Functions["Utility Functions"]
+ Sapiens_Prediction_Engine["Sapiens Prediction Engine"]
+ CLI_Interface -- "invokes" --> Core_Humanization_Logic
+ CLI_Interface -- "uses" --> Humanness_Scoring
+ CLI_Interface -- "uses" --> Utility_Functions
+ Web_Interface -- "initializes parameters for" --> Core_Humanization_Logic
+ Web_Interface -- "triggers" --> Humanization_Task_Management
+ Web_Interface -- "reads input via" --> Utility_Functions
+ Humanization_Task_Management -- "executes" --> Core_Humanization_Logic
+ Humanization_Task_Management -- "calculates scores using" --> Humanness_Scoring
+ Humanization_Task_Management -- "uses" --> Utility_Functions
+ Core_Humanization_Logic -- "utilizes" --> Sapiens_Prediction_Engine
+ Core_Humanization_Logic -- "uses" --> Utility_Functions
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+The BioPhi antibody humanization system provides both command-line and web interfaces for transforming non-human antibody sequences into human-like sequences. It orchestrates asynchronous humanization tasks, leveraging core algorithms like Sapiens deep learning and CDR Grafting, and includes functionalities for humanness scoring and general utility operations.
+
+### CLI Interface
+This component provides command-line interfaces for antibody humanization, allowing users to interactively humanize sequences, get scores, or generate FASTA outputs. It primarily invokes the core humanization methods.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.cli.sapiens:sapiens_interactive` (127:137)
+- `biophi.humanization.cli.sapiens:sapiens_scores_only` (140:183)
+- `biophi.humanization.cli.sapiens:sapiens_fasta_only` (186:212)
+
+
+### Web Interface
+This component handles web-based requests for antibody humanization. It manages GET and POST requests, retrieves germline lists, and initializes various humanization parameters based on user input.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.web.views:humanize_get` (38:93)
+- `biophi.humanization.web.views:humanize_post` (97:160)
+- `biophi.humanization.web.views:designer_get` (285:302)
+- `biophi.humanization.web.views._get_germline_lists` (28:34)
+
+
+### Humanization Task Management
+This component is responsible for orchestrating asynchronous humanization tasks, particularly for the web interface. It initiates the core humanization process, handles task results, and calculates humanness scores.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.web.tasks:humanize_antibody_task` (123:171)
+- `biophi.humanization.web.tasks.HumanizeAntibodyTaskResult` (24:119)
+- `biophi.humanization.web.tasks.HumanizeAntibodyTaskResult:get_export_name` (91:99)
+- `biophi.humanization.web.tasks.HumanizeAntibodyTaskError` (17:20)
+
+
+### Core Humanization Logic
+This component encapsulates the primary algorithms and methods for antibody humanization, including the Sapiens deep learning model and CDR Grafting techniques. It defines the parameters and processes for transforming non-human antibody sequences into human-like sequences, focusing on sequence modification and optimization.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.methods.humanization.HumanizationParams` (14:20)
+- `biophi.humanization.methods.humanization.SapiensHumanizationParams` (24:38)
+- `biophi.humanization.methods.humanization.CDRGraftingHumanizationParams` (42:60)
+- `biophi.humanization.methods.humanization.ManualHumanizationParams` (64:68)
+- `biophi.humanization.methods.humanization.HumanizedResidueAnnot` (72:74)
+- `biophi.humanization.methods.humanization.ChainHumanization` (78:117)
+- `biophi.humanization.methods.humanization.ChainHumanization.get_alignment_string` (95:97)
+- `biophi.humanization.methods.humanization.ChainHumanization.to_score_dataframe` (110:117)
+- `biophi.humanization.methods.humanization.AntibodyHumanization` (121:155)
+- `biophi.humanization.methods.humanization.AntibodyHumanization.get_alignment_string` (141:147)
+- `biophi.humanization.methods.humanization.AntibodyHumanization.to_score_dataframe` (149:155)
+- `biophi.humanization.methods.humanization:humanize_antibody` (158:162)
+- `biophi.humanization.methods.humanization:humanize_chain` (165:175)
+- `biophi.humanization.methods.humanization:cdr_grafting_humanize_chain` (178:204)
+- `biophi.humanization.methods.humanization:sapiens_humanize_chain` (207:246)
+
+
+### Humanness Scoring
+This component is responsible for calculating the humanness scores of antibodies, often used as a metric to evaluate the success of the humanization process.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.methods.humanness.OASisParams` (24:34)
+- `biophi.humanization.methods.humanness.get_antibody_humanness` (273:277)
+
+
+### Utility Functions
+This component provides common utility functions used across the BioPhi system, including input/output operations and string formatting for filenames.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.utils.io.read_antibody_input_request` (112:167)
+- `biophi.common.utils.formatting.get_valid_filename` (57:59)
+
+
+### Sapiens Prediction Engine
+This component represents the external Sapiens library, which is used to predict scores for antibody sequences, forming a crucial part of the Sapiens humanization method.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.methods.humanization:sapiens_predict_chain` (249:257)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Core Humanness Analysis.md b/.codeboarding/Core Humanness Analysis.md
new file mode 100644
index 0000000..2fbc220
--- /dev/null
+++ b/.codeboarding/Core Humanness Analysis.md
@@ -0,0 +1,110 @@
+```mermaid
+graph LR
+ User_Interface_CLI["User Interface & CLI"]
+ Task_Orchestration["Task Orchestration"]
+ Humanness_Data_Models["Humanness Data Models"]
+ Core_Humanness_Analysis["Core Humanness Analysis"]
+ Humanization_Core["Humanization Core"]
+ User_Interface_CLI -- "initiates" --> Task_Orchestration
+ Task_Orchestration -- "orchestrates" --> Core_Humanness_Analysis
+ Task_Orchestration -- "orchestrates" --> Humanization_Core
+ Task_Orchestration -- "processes" --> Humanness_Data_Models
+ Core_Humanness_Analysis -- "calculates using" --> Humanness_Data_Models
+ Humanization_Core -- "processes/produces" --> Humanness_Data_Models
+ Humanness_Data_Models -- "structures data for" --> Core_Humanness_Analysis
+ Humanness_Data_Models -- "structures data for" --> Humanization_Core
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+This architecture outlines the BioPhi humanization subsystem, which processes antibody sequences to assess and improve their 'humanness'. The `User Interface & CLI` component serves as the entry point, receiving user input. This input is then passed to the `Task Orchestration` component, which manages the asynchronous execution of either humanness analysis or humanization tasks. The `Core Humanness Analysis` component performs the detailed calculation of humanness scores using methods like OASis, relying on data structures defined in `Humanness Data Models`. Similarly, the `Humanization Core` component modifies antibody sequences to increase humanness, also interacting with `Humanness Data Models` for data representation. The `Humanness Data Models` component acts as a central data repository, structuring information for both analysis and humanization processes.
+
+### User Interface & CLI
+This component handles user interactions, including receiving antibody sequences and humanization parameters via web forms or command-line interfaces. It is responsible for initiating the core humanization and humanness calculation processes.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.cli.oasis:oasis` (19:96)
+- `biophi.humanization.cli.sapiens:sapiens` (33:124)
+- `biophi.humanization.web.views:humanize_post` (97:160)
+- `biophi.humanization.web.views:humanness_post` (333:361)
+
+
+### Task Orchestration
+This component manages the asynchronous execution of humanization and humanness calculation tasks. It schedules tasks, monitors their progress, and provides methods for retrieving and formatting results for display or export.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.web.tasks.HumanizeAntibodyTaskResult:to_series` (32:43)
+- `biophi.humanization.web.tasks.HumanizeAntibodyTaskResult:to_sheets` (70:89)
+- `biophi.humanization.web.tasks:humanize_antibody_task` (123:171)
+- `biophi.humanization.web.tasks:mutate_humanized_antibody_task` (175:205)
+- `biophi.humanization.web.tasks.HumannessTaskResult:to_series` (220:244)
+- `biophi.humanization.web.tasks.HumannessTaskResult:to_sheets` (260:276)
+- `biophi.humanization.web.tasks:humanness_task` (287:312)
+
+
+### Humanness Data Models
+This component defines the core data structures used to represent and encapsulate humanness-related information for peptides, individual antibody chains, and complete antibodies. These models also include methods for data manipulation and formatting.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.methods.humanness.OASisParams` (24:34)
+- `biophi.humanization.methods.humanness.PeptideHumanness` (38:56)
+- `biophi.humanization.methods.humanness.ChainHumanness` (60:195)
+- `biophi.humanization.methods.humanness.AntibodyHumanness` (199:255)
+
+
+### Core Humanness Analysis
+Dedicated to calculating and assessing the humanness of antibody sequences, primarily using the OASis method. It includes statistical functions to determine humanness scores, identify non-human peptides, and generate related metrics, providing quantitative insights into sequence humanness.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.methods.humanness` (full file reference)
+- `biophi.humanization.methods.stats` (full file reference)
+- `biophi.humanization.methods.humanness.get_antibody_humanness` (273:277)
+- `biophi.humanization.methods.humanness.get_chain_humanness` (319:343)
+- `biophi.humanization.methods.humanness.get_chain_oasis_peptides` (280:316)
+- `biophi.humanization.methods.humanness.parse_peptide_humanness` (346:352)
+- `biophi.humanization.methods.humanness.chop_seq_peptides` (258:270)
+- `biophi.humanization.methods.humanness.get_oas_hits` (355:367)
+- `biophi.humanization.methods.humanness.get_fraction_subjects_bin` (374:377)
+- `biophi.humanization.methods.humanness.ChainHumanness.get_oasis_curve` (76:87)
+- `biophi.humanization.methods.humanness.ChainHumanness.get_oasis_identity` (89:90)
+- `biophi.humanization.methods.humanness.ChainHumanness.get_oasis_percentile` (92:97)
+- `biophi.humanization.methods.humanness.ChainHumanness.get_num_human_peptides` (107:108)
+- `biophi.humanization.methods.humanness.ChainHumanness.get_num_nonhuman_peptides` (110:111)
+- `biophi.humanization.methods.humanness.ChainHumanness.get_num_peptides` (113:114)
+- `biophi.humanization.methods.humanness.AntibodyHumanness.get_oasis_identity` (203:204)
+- `biophi.humanization.methods.humanness.AntibodyHumanness.get_oasis_percentile` (206:211)
+- `biophi.humanization.methods.humanness.AntibodyHumanness.get_num_human_peptides` (228:230)
+- `biophi.humanization.methods.humanness.AntibodyHumanness.get_num_nonhuman_peptides` (232:234)
+- `biophi.humanization.methods.humanness.AntibodyHumanness.get_num_peptides` (225:226)
+- `biophi.humanization.methods.stats.get_oasis_percentile` (full file reference)
+- `biophi.humanization.methods.stats.get_germline_family_residue_frequency` (full file reference)
+- `biophi.humanization.methods.stats.get_chain_type_residue_frequency` (full file reference)
+- `biophi.humanization.methods.stats._get_frequency` (full file reference)
+
+
+### Humanization Core
+This component is responsible for the actual humanization process of antibody sequences, distinct from humanness analysis. It contains algorithms for modifying sequences to increase their humanness.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.methods.humanization` (full file reference)
+- `biophi.humanization.methods.humanization.CDRGraftingHumanizationParams` (42:60)
+- `biophi.humanization.methods.humanization.ManualHumanizationParams` (64:68)
+- `biophi.humanization.methods.humanization.SapiensHumanizationParams` (24:38)
+- `biophi.humanization.methods.humanization.AntibodyHumanization` (121:155)
+- `biophi.humanization.methods.humanization.ChainHumanization` (78:117)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/User Interface & CLI.md b/.codeboarding/User Interface & CLI.md
new file mode 100644
index 0000000..18c3d14
--- /dev/null
+++ b/.codeboarding/User Interface & CLI.md
@@ -0,0 +1,125 @@
+```mermaid
+graph LR
+ Humanization_CLI["Humanization CLI"]
+ Humanization_Web["Humanization Web"]
+ Common_Infrastructure["Common Infrastructure"]
+ Humanization_Core["Humanization Core"]
+ Humanness_Core["Humanness Core"]
+ Task_Management["Task Management"]
+ IO_Utilities["IO Utilities"]
+ Sequence_Formatting["Sequence & Formatting"]
+ Stats_Logging["Stats & Logging"]
+ Humanization_CLI -- "uses" --> IO_Utilities
+ Humanization_CLI -- "initiates" --> Humanization_Core
+ Humanization_CLI -- "initiates" --> Humanness_Core
+ Humanization_CLI -- "schedules" --> Task_Management
+ Humanization_Web -- "handles requests for" --> Task_Management
+ Humanization_Web -- "uses" --> IO_Utilities
+ Humanization_Web -- "configures" --> Humanization_Core
+ Humanization_Web -- "configures" --> Humanness_Core
+ Task_Management -- "executes" --> Humanization_Core
+ Task_Management -- "executes" --> Humanness_Core
+ IO_Utilities -- "relies on" --> Sequence_Formatting
+ IO_Utilities -- "logs via" --> Stats_Logging
+ Common_Infrastructure -- "integrates" --> Humanization_CLI
+ Common_Infrastructure -- "integrates" --> Humanization_Web
+ Common_Infrastructure -- "uses" --> Sequence_Formatting
+ Common_Infrastructure -- "uses" --> Stats_Logging
+ Common_Infrastructure -- "manages" --> Task_Management
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+This component provides the primary interaction points for users, encompassing both command-line interfaces (CLI) for direct tool execution (OASis, Sapiens) and the web-based interface for broader accessibility. It handles user input, displays results, and orchestrates the initiation of core BioPhi functionalities.
+
+### Humanization CLI
+Provides command-line tools for users to perform antibody humanization (Sapiens) and humanness evaluation (OASis). It parses command-line arguments, loads input files, and orchestrates the execution of the core humanization and humanness logic.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.cli.oasis` (19:96)
+- `biophi.humanization.cli.sapiens` (33:124)
+
+
+### Humanization Web
+Implements the web-based user interface for BioPhi's humanization features. It handles HTTP requests, renders templates, processes form submissions, and interacts with the asynchronous task management system to perform humanization and humanness analysis.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.web.views` (full file reference)
+
+
+### Common Infrastructure
+Provides foundational components for both the command-line and web interfaces, including the main CLI group, Flask application setup, and scheduler integration.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.cli.web` (10:21)
+- `biophi.common.cli.main.MainGroup` (8:22)
+- `biophi.common.web.views` (full file reference)
+- `biophi.common.utils.scheduler` (full file reference)
+
+
+### Humanization Core
+Contains the fundamental algorithms and data structures for performing antibody humanization, including Sapiens and CDR Grafting methods. It defines parameters for humanization and provides functions to humanize individual chains or entire antibodies.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.methods.humanization` (full file reference)
+
+
+### Humanness Core
+Provides the core functionality for evaluating antibody humanness, primarily through the OASis method. It interacts with an OAS peptide database to determine the humanness of antibody sequences.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.methods.humanness` (full file reference)
+
+
+### Task Management
+Manages the execution of long-running humanization and humanness analysis tasks asynchronously, typically using Celery. It defines task results and provides methods for scheduling and retrieving task outcomes.
+
+
+**Related Classes/Methods**:
+
+- `biophi.humanization.web.tasks` (full file reference)
+- `biophi.common.web.tasks` (full file reference)
+
+
+### IO Utilities
+A collection of utility functions for handling various input and output operations, including parsing antibody sequence files (FASTA, PDB), reading web requests, and sending data as FASTA, text, or Excel files.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.utils.io` (full file reference)
+
+
+### Sequence & Formatting
+Contains general utility functions for sequence manipulation (validation, sanitization, parsing FASTA/PDB) and formatting output (logos, valid filenames, human-readable sizes).
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.utils.seq` (full file reference)
+- `biophi.common.utils.formatting` (full file reference)
+
+
+### Stats & Logging
+Manages the collection and storage of application statistics and logs, including submission details, task results, and access logs.
+
+
+**Related Classes/Methods**:
+
+- `biophi.common.utils.stats` (full file reference)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/on_boarding.md b/.codeboarding/on_boarding.md
new file mode 100644
index 0000000..d3e6818
--- /dev/null
+++ b/.codeboarding/on_boarding.md
@@ -0,0 +1,88 @@
+```mermaid
+graph LR
+ User_Interface_CLI["User Interface & CLI"]
+ Core_Humanization_Logic["Core Humanization Logic"]
+ Core_Humanness_Analysis["Core Humanness Analysis"]
+ Background_Task_Processing["Background Task Processing"]
+ Common_Utilities["Common Utilities"]
+ User_Interface_CLI -- "Invokes" --> Core_Humanization_Logic
+ User_Interface_CLI -- "Invokes" --> Core_Humanness_Analysis
+ User_Interface_CLI -- "Submits tasks to" --> Background_Task_Processing
+ User_Interface_CLI -- "Utilizes" --> Common_Utilities
+ Background_Task_Processing -- "Executes" --> Core_Humanization_Logic
+ Background_Task_Processing -- "Executes" --> Core_Humanness_Analysis
+ Background_Task_Processing -- "Logs via" --> Common_Utilities
+ Core_Humanization_Logic -- "Depends on" --> Common_Utilities
+ Core_Humanization_Logic -- "Utilizes" --> Core_Humanness_Analysis
+ Core_Humanness_Analysis -- "Depends on" --> Common_Utilities
+ click User_Interface_CLI href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/BioPhi/User Interface & CLI.md" "Details"
+ click Core_Humanization_Logic href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/BioPhi/Core Humanization Logic.md" "Details"
+ click Core_Humanness_Analysis href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/BioPhi/Core Humanness Analysis.md" "Details"
+ click Background_Task_Processing href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/BioPhi/Background Task Processing.md" "Details"
+ click Common_Utilities href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/BioPhi/Common Utilities.md" "Details"
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+This architecture analysis for BioPhi outlines the core components and their interactions within the system. The main flow involves user interaction through CLI or web interfaces, which can directly invoke core humanization or humanness analysis logic, or offload computationally intensive tasks to a background processing system. All components rely on a shared set of common utilities for data handling, I/O, logging, and system-level operations, ensuring efficient and consistent functionality across the application.
+
+### User Interface & CLI
+This component provides the primary interaction points for users, encompassing both command-line interfaces (CLI) for direct tool execution (OASis, Sapiens) and the web-based interface for broader accessibility. It handles user input, displays results, and orchestrates the initiation of core BioPhi functionalities.
+
+
+**Related Classes/Methods**:
+
+- `BioPhi.biophi.humanization.cli.oasis` (19:96)
+- `BioPhi.biophi.humanization.cli.sapiens` (33:124)
+- `BioPhi.biophi.common.cli.web` (10:21)
+- `BioPhi.biophi.common.cli.main.MainGroup` (8:22)
+- `BioPhi.biophi.humanization.web.views` (full file reference)
+- `BioPhi.biophi.common.web.views` (full file reference)
+
+
+### Core Humanization Logic
+This component encapsulates the primary algorithms and methods for antibody humanization, including the Sapiens deep learning model and CDR Grafting techniques. It defines the parameters and processes for transforming non-human antibody sequences into human-like sequences, focusing on sequence modification and optimization.
+
+
+**Related Classes/Methods**:
+
+- `BioPhi.biophi.humanization.methods.humanization` (full file reference)
+
+
+### Core Humanness Analysis
+Dedicated to calculating and assessing the humanness of antibody sequences, primarily using the OASis method. It includes statistical functions to determine humanness scores, identify non-human peptides, and generate related metrics, providing quantitative insights into sequence humanness.
+
+
+**Related Classes/Methods**:
+
+- `BioPhi.biophi.humanization.methods.humanness` (full file reference)
+- `BioPhi.biophi.humanization.methods.stats` (full file reference)
+
+
+### Background Task Processing
+Responsible for managing and executing long-running, computationally intensive tasks asynchronously. It utilizes a scheduler (e.g., Celery) to offload operations like humanization and humanness calculations from the main application thread, ensuring responsiveness and efficient resource utilization.
+
+
+**Related Classes/Methods**:
+
+- `BioPhi.biophi.humanization.web.tasks` (full file reference)
+- `BioPhi.biophi.common.web.tasks` (full file reference)
+- `BioPhi.biophi.common.utils.scheduler` (full file reference)
+
+
+### Common Utilities
+Provides foundational utilities for input/output operations, including parsing antibody files (FASTA, PDB), handling sequence data, and managing data structures. It also offers general system utilities such as logging, statistics tracking, and text formatting, supporting robust data handling, monitoring, and consistent information presentation across the application.
+
+
+**Related Classes/Methods**:
+
+- `BioPhi.biophi.common.utils.io` (full file reference)
+- `BioPhi.biophi.common.utils.seq` (full file reference)
+- `BioPhi.biophi.common.utils.stats` (full file reference)
+- `BioPhi.biophi.common.utils.formatting` (full file reference)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file