QuCo: Quantum Algorithms Workshop UCLA
November 11, 2025 to November 12, 2025
James West Alumni Center, UCLA
Prizes
1st Prize
Internship Opportunity
2nd Prize
Internship Opportunity
3rd Prize
Internship Opportunity
Fetch.ai is your gateway to the agentic economy. It provides a full ecosystem for building, deploying, and discovering AI Agents. With Fetch.ai, you can:
- Build agents using the uAgents framework.
- Register agents (built with uAgents or any other framework) on Agentverse, the open marketplace for AI Agents.
- Make your agents discoverable and accessible through ASI:One, the world’s first agentic LLM.
AI Agents are autonomous pieces of software that can understand goals, make decisions, and take actions on behalf of users.
The Three Pillars of the Fetch.ai Ecosystem
- uAgents – A Python library developed by Fetch.ai for building autonomous agents. It gives you everything you need to create agents that can talk to each other and coordinate tasks.
- Agentverse - The open marketplace for AI Agents. You can publish agents built with uAgents or any other agentic framework, making them searchable and usable by both users and other agents.
- ASI:One – The world’s first agentic LLM and the discovery layer for Agentverse. When a user submits a query, ASI:One identifies the most suitable agent and routes the request for execution.
Challenge statement
Quantum Hackathon Challenge: Molecular Geometry Optimization
1. Introduction and Motivation
The ability to precisely predict the structure of molecules is central to fields like chemistry, materials science, and drug discovery. While classical computation struggles with the exponential complexity of large quantum systems, quantum computers offer a path forward.
Motivation: Google's Willow QC Research
The recent paper, "Quantum computation of molecular geometry via many-body nuclear spin echoes," demonstrated a breakthrough by using the Willow superconducting quantum computer in a hybrid approach to determine molecular geometry.
i. The Research Question: The researchers' goal was to find the precise atomic distances (geometry) of molecules like toluene and 3',5'-dimethylbiphenyl (DMBP). ii. The Method: Instead of directly solving for the geometry, they simulated the complex Out-of-Time-Ordered Correlator (OTOC) dynamics of the molecule's nuclear spins. iii. The Hybrid Approach: They used a classical-quantum feedback loop where the quantum computer ran a Trotterized simulation of the spin Hamiltonian (encoded with a candidate geometry), and a classical optimizer adjusted the geometry until the simulated results matched experimental data.
The Hackathon Challenge: Your task is to implement a downscaled version of this core problem—molecular geometry optimization—using the Variational Quantum Eigensolver (VQE) algorithm and the Qiskit Nature toolkit. You will find the stable bond length of simple molecules by minimizing their ground state energy.
2. The Core Challenge: $H_2$ Bond Length Optimization
The Variational Quantum Eigensolver (VQE) is a hybrid quantum-classical algorithm used to find the ground state energy of a molecular Hamiltonian. By performing VQE at various bond lengths, you can map the molecule’s Potential Energy Surface (PES) and find the equilibrium bond length where the energy is minimized.
Task 1: Hydrogen Molecule ($H_2$) - The Standard Model
The simplest molecule, $H_2$, allows for rapid iteration and testing on simulators or real quantum hardware (using just 2-4 qubits).
Goal: Determine the equilibrium bond length ($r_{eq}$) of the $H_2$ molecule.
Steps:
- Define Molecular Geometry Range: Use a classical chemistry driver (e.g., PySCF) within Qiskit Nature to define the $H_2$ molecule for a range of inter-atomic distances (e.g., $r = 0.5 \AA$ to $2.5 \AA$).
- Generate the Hamiltonian: For each distance $r_i$, generate the corresponding Electronic Structure Hamiltonian in the second-quantized form, map it to a Qubit Hamiltonian (using mappers like Jordan-Wigner or Parity), and reduce the number of qubits using symmetries.
- Implement VQE: i. Ansatz: Design a variational circuit ($\vert\Psi(\vec{\theta})\rangle$). The Unitary Coupled Cluster Singles and Doubles (UCCSD) ansatz is standard, but a simpler EfficientSU2 can be used for initial testing. ii. Optimizer: Use a classical optimizer (e.g., COBYLA, SLSQP) to find the parameters ($\vec{\theta}^*$) that minimize the expectation value $\langle\Psi(\vec{\theta})\vert H_i \vert\Psi(\vec{\theta})\rangle$.
- Analyze Results: Plot the minimum energy found ($E_i$) against the bond length ($r_i$) to generate the Potential Energy Surface (PES) curve. The minimum point of this curve is the $r_{eq}$.
- Deliverable: Plot the PES curve and state the calculated $r_{eq}$ value.
3. Stretch Goal: Scaling the Problem
For teams that successfully and efficiently complete the $H_2$ challenge, the next level is to tackle a slightly more complex system that requires a larger number of qubits and features a more complex geometry.
Task 2: Trihydrogen Cation ($H_3^+$)
The trihydrogen cation ($H_3^+$) is a 3-atom molecule and the most abundant molecular ion in the universe. Its ground state geometry is an equilateral triangle.
Goal: Determine the equilibrium bond length ($r_{eq}$) of the $H_3^+$ molecule in its equilateral configuration.
Steps:
- Setup: Define the $H_3^+$ molecule in the geometry of an equilateral triangle, where the only variable is the side length $r$.
- Qubit Challenge: $H_3^+$ is more demanding on qubits (typically 6-8 qubits before reduction). Teams must carefully select their mapper and utilize symmetry reduction to run the problem on a 5-7 qubit simulator/device.
- Execution and Optimization: Repeat the VQE workflow (Steps 2-4 from Task 1) to generate the PES curve and find the minimum energy bond length. Deliverable: Plot the PES curve for $H_3^+$ and state the calculated $r_{eq}$.
Bonus Error Mitigation: Implement error mitigation techniques like Zero Noise Extrapolation on simulated noisy backends (using Aer noise models)
4. Tools and Resources
i. Quantum SDK: Qiskit (specifically qiskit-nature) or any other preferred Python-based SDK. ii. Backend: Qiskit Aer simulators or any other preferred quantum simulator. iii. Classical Driver: PySCF (integrated via Qiskit Nature) or any other preferred.
Tool Stack
Quick start example
This file can be run on any platform supporting Python, with the necessary install permissions. This example shows two agents communicating with each other using the uAgent python library.
Try it out on Agentverse ↗
from datetime import datetime
from uuid import uuid4
from uagents.setup import fund_agent_if_low
from uagents_core.contrib.protocols.chat import (
ChatAcknowledgement,
ChatMessage,
EndSessionContent,
StartSessionContent,
TextContent,
chat_protocol_spec,
)
agent = Agent()
# Initialize the chat protocol with the standard chat spec
chat_proto = Protocol(spec=chat_protocol_spec)
# Utility function to wrap plain text into a ChatMessage
def create_text_chat(text: str, end_session: bool = False) -> ChatMessage:
content = [TextContent(type="text", text=text)]
return ChatMessage(
timestamp=datetime.utcnow(),
msg_id=uuid4(),
content=content,
)
# Handle incoming chat messages
@chat_proto.on_message(ChatMessage)
async def handle_message(ctx: Context, sender: str, msg: ChatMessage):
ctx.logger.info(f"Received message from {sender}")
# Always send back an acknowledgement when a message is received
await ctx.send(sender, ChatAcknowledgement(timestamp=datetime.utcnow(), acknowledged_msg_id=msg.msg_id))
# Process each content item inside the chat message
for item in msg.content:
# Marks the start of a chat session
if isinstance(item, StartSessionContent):
ctx.logger.info(f"Session started with {sender}")
# Handles plain text messages (from another agent or ASI:One)
elif isinstance(item, TextContent):
ctx.logger.info(f"Text message from {sender}: {item.text}")
#Add your logic
# Example: respond with a message describing the result of a completed task
response_message = create_text_chat("Hello from Agent")
await ctx.send(sender, response_message)
# Marks the end of a chat session
elif isinstance(item, EndSessionContent):
ctx.logger.info(f"Session ended with {sender}")
# Catches anything unexpected
else:
ctx.logger.info(f"Received unexpected content type from {sender}")
# Handle acknowledgements for messages this agent has sent out
@chat_proto.on_message(ChatAcknowledgement)
async def handle_acknowledgement(ctx: Context, sender: str, msg: ChatAcknowledgement):
ctx.logger.info(f"Received acknowledgement from {sender} for message {msg.acknowledged_msg_id}")
# Include the chat protocol and publish the manifest to Agentverse
agent.include(chat_proto, publish_manifest=True)
if __name__ == "__main__":
agent.run()




Examples to get you started:
Judging Criteria
Prizes
1st Prize
Internship Opportunity
2nd Prize
Internship Opportunity
3rd Prize
Internship Opportunity
Judges

Attila Bagoly
Chief AI Officer

Sana Wajid
Chief Development Officer - Fetch.ai
Senior Vice President - Innovation Lab
Mentors

Karen Mosoyan
Intern

Ryan Tran
Intern
Schedule
10:00 PST
Fetch.ai Challenge Talk
James West Alumni Center, UCLA
11:00 PST
Fetch.ai Challenge Work Session
James West Alumni Center, UCLA