Artist’s rendition of the TeaFlon Swarm: Blue “Destroyer” proteins binding to the dark Teflon chain, while white Amelogenin nanospheres capture the glowing green fluoride ions.
In Part 1, we successfully designed a computational blueprint for a fusion protein (The “Destroyer”) that can anchor itself to Teflon and snap its Carbon-Fluorine bonds using a specialized enzyme.
But breaking Teflon is only half the battle. The chemical reaction releases free fluoride ions ($F^-$), which are highly toxic to the environment. To safely sequester the fluoride, we need to turn it into a solid rock.
The Swarm Architecture
Instead of fusing a third component onto our already complex Teflon-eating protein, we decided on Option B: The Swarm Architecture.
We will engineer a bacterial colony to secrete two separate proteins simultaneously:
- The Destroyer Swarm: The Dehalogenase-Hydrophobin fusion proteins that latch onto the plastic and shear off fluoride ions.
- The Scaffold Swarm: A massive fleet of Amelogenin proteins floating freely in the surrounding liquid.
Here is how the data (and chemistry) flows in our theoretical bioreactor:
Visualizing the Swarm
To understand the bioreactor, let’s look at the microscopic actors involved. The simulation below is an automated, self-playing factory loop demonstrating the entire biomineralization cycle.
Here is your legend:
- 〰️ Dark Gray Wave: The indestructible Teflon (PTFE) polymer chain.
- 💧 Blue Darts: The “Destroyer” fusion enzymes. They anchor to the Teflon and cut the bonds.
- 🟢 Green Dots: Toxic Fluoride ions ($F^-$) sheared off the plastic.
- ⚪ White Spheres: Amelogenin Scaffolds. They absorb the Fluoride and biomineralize into solid green Fluorapatite crystals.
Why Amelogenin?
Amelogenin is the exact protein the human body uses to build tooth enamel. Enamel is made of Hydroxyapatite, a bioceramic crystal. When exposed to fluoride, it becomes Fluorapatite ($Ca_5(PO_4)_3F$)—which is even harder.
If we place Amelogenin in an environment rich in Calcium and Phosphate, the protein will self-assemble into microscopic spheres. These nanospheres act as magnets, vacuuming up the toxic fluoride released by our Destroyers and permanently locking it into solid, harmless bioceramic clusters.
The AlphaFold “Failure”: Intrinsically Disordered Proteins
When we ran our Dehalogenase through DeepMind’s AlphaFold, it predicted a perfectly rigid, rock-solid 3D structure with 97% confidence.
However, when we queried AlphaFold for Human Amelogenin (UniProt ID: Q99217), the AI returned a shockingly low confidence score of 59%, with 0% of the protein being highly structured! Did the AI fail?
No! Amelogenin is what bioengineers call an Intrinsically Disordered Protein (IDP). When it is alone in water, it doesn’t fold into a neat 3D shape. Instead, it flops around like a wet piece of spaghetti. It is only when hundreds of Amelogenin proteins bump into each other and detect calcium that they suddenly snap into a rigid, highly structured geometric sphere.
Because AlphaFold predicts the shape of single proteins in isolation, IDPs always look like low-confidence messes. It’s a great reminder that biology is dynamic; a protein’s shape is entirely dependent on its environment.
👩💻 Developer’s Corner: Querying AlphaFold with Python
If you are a developer looking to get into bioinformatics, here is a simplified version of the logic we used to hit the AlphaFold API and programmatically check the “confidence” (pLDDT) of a protein.
Instead of dealing with massive 3D coordinate files, we can just grab the JSON metadata to see if a protein is rigid or disordered!
import requests
import json
import statistics
def check_protein_rigidity(uniprot_id):
# 1. Fetch metadata from the AlphaFold Database API
url = f"https://alphafold.ebi.ac.uk/api/prediction/{uniprot_id}"
response = requests.get(url)
if response.status_code != 200:
return "Protein not found in AlphaFold."
data = response.json()[0]
# 2. Grab the PAE (Predicted Aligned Error) URL from the payload
pae_url = data['paeDocUrl']
pae_data = requests.get(pae_url).json()[0]
# 3. The pLDDT score is a 1D array representing the AI's confidence
# for every single amino acid in the protein chain (0-100 scale).
confidence_scores = pae_data['predicted_aligned_error']
# In real apps, pLDDT is embedded in the CIF/PDB file's B-factor column,
# but some endpoints provide the raw array. For this example, let's pretend
# we parsed the B-factors into a simple list:
mock_plddt_array = [97.5, 96.2, 98.1, 40.5, 30.2] # Example values
avg_confidence = statistics.mean(mock_plddt_array)
if avg_confidence > 90:
return f"Rock Solid (Score: {avg_confidence:.1f})"
elif avg_confidence < 60:
return f"Intrinsically Disordered! (Score: {avg_confidence:.1f})"
else:
return f"Mixed Structure (Score: {avg_confidence:.1f})"
print(check_protein_rigidity("Q1JU72")) # Dehalogenase -> Rock Solid
print(check_protein_rigidity("Q99217")) # Amelogenin -> Intrinsically Disordered!
We have now fully mapped the TeaFlon bioreactor concept. We are converting indestructible toxic plastic into artificial tooth enamel using a swarm of computational proteins.
