Tejas Khot tejaskhot

I wrote an in-depth research prompt to conduct a GPT-Deep-Research on the Manus topic, seeking to replicate it with currently available open source tools. This is the result:

TLDR: Manus AI Agent Report

Manus is an autonomous AI agent built as a wrapper around foundation models (primarily Claude 3.5/3.7 and Alibaba's Qwen). It operates in a cloud-based virtual computing environment with full access to tools like web browsers, shell commands, and code execution. The system's key innovation is using executable Python code as its action mechanism ("CodeAct" approach), allowing it to perform complex operations autonomously. The architecture consists of an iterative agent loop (analyze → plan → execute → observe), with specialized modules for planning, knowledge retrieval, and memory management. Manus uses file-based memory to track progress and store information across operations. The system can be replicated using open-source components including CodeActAgent (a fine-tuned Mistral model), Docker for sandbox

Cross Entropy Method

How do we solve for the policy optimization problem which is to maximize the total reward given some parametrized policy?

Discounted future reward

To begin with, for an episode the total reward is the sum of all the rewards. If our environment is stochastic, we can never be sure if we will get the same rewards the next time we perform the same actions. Thus the more we go into the future the more the total future reward may diverge. So for that reason it is common to use the discounted future reward where the parameter discount is called the discount factor and is between 0 and 1.

A good strategy for an agent would be to always choose an action that maximizes the (discounted) future reward. In other words we want to maximize the expected reward per episode.

Interactive Machine Learning

Taught by Brad Knox at the MIT Media Lab in 2014. Course website. Lecture and visiting speaker notes.

Power to the People: The Role of Humans in Interactive Machine Learning by Knox, Cakmak, Kulesza, Amershi, and Lau
A Few Useful Things to Know about Machine Learning by Domingos
Machine Learning that Matters by Wagstaff
Beyond Concise and Colorful: Learning Intelligible Rules by Pazzani et al.
[Designing Games with a Purpose] (https://www.cs.cmu.edu/~biglou/GWAP_CACM.pdf) by von Ahn and Dabbish
[Human Model Evaluation in Interactive Supervised

	You are Manus, an AI agent created by the Manus team.

	You excel at the following tasks:
	1. Information gathering, fact-checking, and documentation
	2. Data processing, analysis, and visualization
	3. Writing multi-chapter articles and in-depth research reports
	4. Creating websites, applications, and tools
	5. Using programming to solve various problems beyond development
	6. Various tasks that can be accomplished using computers and the internet

	You are an assistant that engages in extremely thorough, self-questioning reasoning. Your approach mirrors human stream-of-consciousness thinking, characterized by continuous exploration, self-doubt, and iterative analysis.

	## Core Principles

	1. EXPLORATION OVER CONCLUSION
	- Never rush to conclusions
	- Keep exploring until a solution emerges naturally from the evidence
	- If uncertain, continue reasoning indefinitely
	- Question every assumption and inference

	import torch


	def chamfer_distance_without_batch(p1, p2, debug=False):

	'''
	Calculate Chamfer Distance between two point sets
	:param p1: size[1, N, D]
	:param p2: size[1, M, D]
	:param debug: whether need to output debug info

	'''
	This script is based on the original work of Randal S. Olson (randalolson.com) for the Traveling Salesman Portrait project.
	http://www.randalolson.com/2018/04/11/traveling-salesman-portrait-in-python/

	Please check out the original project repository for information:

	https://github.com/rhiever/Data-Analysis-and-Machine-Learning-Projects

	The script was updated by Joshua L. Adelman, adapting the work of Antonio S. Chinchón described in the following blog post:
	https://fronkonstin.com/2018/04/17/pencil-scribbles/

	import tensorflow as tf

	"""
	Author : @MikiBear_
	Tensorflow Implementation of Bilinear Additive Upsampling.
	Reference : https://arxiv.org/abs/1707.05847
	"""
	def bilinear_additive_upsampling(x, to_channel_num, name):
	from_channel_num = x.get_shape().as_list()[3]
	assert from_channel_num % to_channel_num == 0

	# http://pytorch.org/tutorials/beginner/transfer_learning_tutorial.html

	def exp_lr_scheduler(optimizer, epoch, init_lr=0.001, lr_decay_epoch=7):
	"""Decay learning rate by a factor of 0.1 every lr_decay_epoch epochs."""
	lr = init_lr * (0.1**(epoch // lr_decay_epoch))

	if epoch % lr_decay_epoch == 0:
	print('LR is set to {}'.format(lr))

	for param_group in optimizer.param_groups:

	""" Deep Auto-Encoder implementation

	An auto-encoder works as follows:

	Data of dimension k is reduced to a lower dimension j using a matrix multiplication:
	softmax(W*x + b) = x'

	where W is matrix from R^k --> R^j

	A reconstruction matrix W' maps back from R^j --> R^k