Hey PaperLedge crew, Ernis here, ready to dive into some fascinating research! Today, we’re tackling a paper that explores how to make AI agents, especially those powered by smaller language models, better team players.
Think of it this way: imagine you're trying to cook a meal with a friend, but they keep grabbing the wrong ingredients or doing things out of order. It's frustrating, right? That's kind of what happens when these AI agents try to collaborate. They often make mistakes because they're focusing on surface-level correlations – basically, they see that sometimes grabbing the tomatoes leads to a salad, but they don't understand why or when that's the right thing to do.
This paper introduces a clever solution called CausalPlan. It's a two-step framework designed to help these AI agents understand the cause and effect of their actions, instead of just relying on simple patterns.
So, how does CausalPlan work? Well, it's like giving the AI a set of instructions – a causal map – that shows how different actions and situations lead to different outcomes. It does this in two phases:

Phase 1: Learning the Causal Map. The AI watches what happens as it and other agents perform the task. It figures out, "Okay, when I do this, it causes that to happen." This is done using something called a Structural Causal Action (SCA) model, which essentially builds a diagram showing the relationships between actions and their consequences.


Phase 2: Using the Causal Map to Plan. Now, when the AI needs to decide what to do, it uses this causal map to evaluate its options. It asks itself, "If I do this, what's likely to happen, and is that a good thing?" It then uses this information to choose the best course of action.

Think of it like this: imagine you're teaching a child to build a tower of blocks. At first, they might just randomly stack blocks, causing the tower to fall. But as they learn, they start to understand that putting the big blocks on the bottom and the small blocks on top makes the tower more stable. CausalPlan helps AI agents learn in a similar way.
The really cool thing is that CausalPlan doesn’t require retraining the entire AI model. It's like adding a GPS system to a car – you don't have to rebuild the whole car, you just add a new tool to help it navigate better. This makes CausalPlan particularly useful for smaller, open-source language models that might not have the resources for extensive retraining.
The researchers tested CausalPlan on a benchmark called Overcooked-AI, which involves AI agents collaborating to prepare meals in a virtual kitchen. They found that CausalPlan significantly reduced the number of invalid actions and improved collaboration, not just between AI agents, but also between AI agents and human players!
"By embedding this causal knowledge directly into the decision loop, CausalPlan constrains planning to intervention-consistent behaviours without requiring fine-tuning of the LLM itself."
So why does this research matter?

For AI developers: CausalPlan offers a practical way to improve the performance and reliability of multi-agent AI systems, especially those using smaller language models.


For anyone interested in AI ethics: By promoting causal reasoning, CausalPlan helps to make AI decision-making more transparent and interpretable. This can lead to more trustworthy and responsible AI systems.


For everyday users of AI: As AI becomes more integrated into our lives, it's important that these systems are able to collaborate effectively and make sound decisions. CausalPlan is a step in that direction.

This research highlights the importance of moving beyond simple pattern recognition and focusing on causal understanding in AI. By giving AI agents the ability to reason about cause and effect, we can create more intelligent, reliable, and collaborative systems.
Here are a couple of questions that come to my mind:

Could CausalPlan be adapted to help AI agents learn from human feedback more effectively? For example, if a human corrects an AI's action, could CausalPlan use that information to update its causal map?


How well does CausalPlan generalize to new tasks or environments? Is it possible that the causal map learned in one environment might not be applicable in another?

That's all for this episode, crew! I hope you found this deep dive into CausalPlan as interesting as I did. Keep exploring, keep learning, and I'll catch you in the next PaperLedge adventure!Credit to Paper authors: Minh Hoang Nguyen, Van Dai Do, Dung Nguyen, Thin Nguyen, Hung Le

Hey PaperLedge crew, Ernis here, ready to dive into some fascinating research! Today, we're tackling a paper about how AI is trying to help doctors make better decisions. Now, medical decision-making is seriously complex, right? Doctors have to juggle tons of information – symptoms, lab results, patient history – it’s like a giant, constantly shifting puzzle.
Researchers have been exploring how Large Language Models, or LLMs (think of them as super-smart AI chatbots), can assist. But here’s the thing: a single LLM, no matter how brilliant, has its limits. It's like asking one person to be an expert in everything – cardiology, dermatology, pediatrics. Impossible!
This paper proposes a clever solution called Expertise-aware Multi-LLM Recruitment and Collaboration (EMRC). Yeah, it's a mouthful, but the idea is pretty cool. Think of it like assembling a dream team of specialists for each case.
Here’s how EMRC works:

Finding the Right Experts: First, the system builds a "resume" for each LLM, detailing its strengths in different medical areas and levels of difficulty. It figures out which LLMs are rockstars in cardiology, which ones ace dermatology questions, and so on. This is done by training the LLMs on publicly available medical information. It’s like creating a digital Rolodex of AI experts.


Assembling the Team: When a new medical query comes in, the system consults its "resume" database and picks the LLMs that are most qualified to handle that specific case. So, instead of relying on one LLM to do it all, you get a team of specialized AI agents working together.


Collaborative Diagnosis: Each selected LLM then generates its own diagnosis, along with a "confidence score" – basically, how sure it is about its answer. The system then combines these diagnoses, giving more weight to the opinions of the most confident LLMs. Then, it uses a technique called adversarial validation, where the LLMs challenge each other's answers to ensure the final result is reliable.

So, why is this a big deal? Well, the researchers tested their EMRC framework on several medical datasets, and the results were impressive! It outperformed both single-LLM approaches and other multi-LLM methods. For example, on one dataset, EMRC achieved almost 75% accuracy, beating even the mighty GPT-4. They found that this approach works because different LLMs have different strengths, and by combining their expertise, you get a much more accurate and reliable diagnosis.
The paper highlights the "agent complementarity in leveraging each LLM's specialized capabilities." That's a fancy way of saying that the system is greater than the sum of its parts!
This research matters because it could potentially improve the accuracy and efficiency of medical decision-making, leading to better patient outcomes. Imagine a future where doctors have access to a team of AI specialists, helping them to diagnose diseases earlier and more accurately.
But, of course, this raises some important questions:

How do we ensure that these AI systems are fair and unbiased, especially when dealing with diverse patient populations?


How do we balance the benefits of AI assistance with the need for human oversight and clinical judgment?


What are the ethical implications of using AI to make life-or-death decisions?

This paper is a step towards a future where AI can be a valuable tool for doctors, helping them to provide the best possible care for their patients. What do you think, PaperLedge crew? Are you excited about the potential of AI in medicine, or do you have concerns about its impact? Let's discuss!Credit to Paper authors: Liuxin Bao, Zhihao Peng, Xiaofei Zhou, Runmin Cong, Jiyong Zhang, Yixuan Yuan

Hey PaperLedge crew, Ernis here, ready to dive into some fascinating research! Today, we're tackling a problem that pops up all the time when scientists are trying to build models from data: How do you figure out which pieces of information are actually important, especially when you have tons of data that's all tangled up together?
Imagine you're trying to bake the perfect cake. You have a recipe with like, 50 ingredients, but some of them are almost the same, like different kinds of flour or sugar. And maybe a few don't even matter that much! Figuring out which ingredients are essential for that perfect flavor is the challenge we're talking about. In data science, that's variable selection – finding the key variables that truly drive the outcome you're interested in.
Now, the paper we're looking at today proposes a really clever solution. It's called a "resample-aggregate framework" using something called "diffusion models." Don't let the name scare you! Think of diffusion models as these awesome AI artists that can create realistic-looking data, almost like making duplicate recipes based on the original, but with slight variations.
Here's the gist:
Step 1: Create Fake Data. The researchers use a diffusion model to generate a bunch of slightly different, but realistic, versions of their original dataset. It's like having multiple copies of your cake recipe, each with tiny tweaks.
Step 2: Identify Important Ingredients in Each Copy. They then use standard statistical tools (like Lasso, which is like a tool that helps you simplify complex equations) to pick out the most important variables in each of these fake datasets. Think of this as identifying the key ingredients in each version of the cake recipe.
Step 3: Count How Often Each Ingredient Appears. Finally, they tally up how often each variable (or cake ingredient) gets selected as important across all the different fake datasets. The ingredients that keep showing up are probably the real stars!
This process of creating multiple fake datasets, finding important variables in each, and then combining the results is what makes their approach so robust. It's like getting opinions from many different bakers to see which ingredients they all agree are essential.
Why is this important? Well, imagine trying to predict stock prices, diagnose a disease, or understand climate change. All these areas rely on complex datasets with lots of interconnected variables. If you can't reliably pick out the right variables, your predictions will be off, and you might make wrong decisions.
This new method seems to do a better job than existing techniques, especially when the data is noisy or when variables are highly correlated (like those similar types of flour in our cake recipe example). The researchers showed, through simulations, that their method leads to more accurate and reliable variable selection.
"By coupling diffusion-based data augmentation with principled aggregation, our method advances variable selection methodology and broadens the toolkit for interpretable, statistically rigorous analysis in complex scientific applications."
And here’s where the "transfer learning" magic comes in. Because diffusion models are often pre-trained on massive datasets, they already have a good understanding of data patterns. It’s like the AI artist already knows a lot about baking before even seeing your specific recipe! This pre-existing knowledge helps the method work even when you have a limited amount of your own data.
This method extends beyond just variable selection; it can be used for other complex tasks like figuring out relationships between variables in a network (like a social network or a biological network). It also provides a way to get valid confidence intervals and test hypotheses, which is crucial for making sound scientific conclusions.
So, what do you all think? Here are a couple of questions that popped into my head:
Given the reliance on pre-trained diffusion models, could there be biases introduced based on the data those models were originally trained on?
While this method seems powerful, what are some situations where it might not be the best approach, and what other tools should researchers consider?
Let's discuss in the comments! I'm eager to hear your thoughts on this intriguing research.Credit to Paper authors: Minjie Wang, Xiaotong Shen, Wei Pan

Hey PaperLedge crew, Ernis here, ready to dive into some seriously cool research! Today, we're tackling a paper that's all about making robots (or AI agents) learn to make decisions better and faster. Think of it like teaching a dog a new trick, but instead of treats, we're using fancy algorithms!
So, the core problem is this: We want AI to learn from past experiences – that's the "offline reinforcement learning" part. Imagine showing a self-driving car a bunch of driving videos and then expecting it to drive itself. The challenge is to make it learn good driving habits from potentially imperfect or incomplete videos. Now, there's this cool technique called "Diffusion Q-Learning," or DQL for short. DQL is like a super smart student that often aces the test. But here's the catch: It takes a long time to figure out the answer. It needs to go through many steps, almost like solving a really complex puzzle one piece at a time.
Imagine trying to draw a perfect circle, but instead of drawing it in one smooth motion, you have to draw a bunch of tiny lines and then erase and redraw them multiple times. That's kind of what DQL is doing! The goal of this paper is to help DQL draw that circle in one smooth stroke!
"DQL stands out as a leading method for its consistently strong performance. Nevertheless, DQL remains limited in practice due to its reliance on multi-step denoising..."
The researchers realized that DQL's problem was that it was using this "multi-step denoising" process to figure out the best action to take. Think of it like this: DQL is trying to find the best route on a map, but instead of looking at the whole map at once, it's only looking at tiny pieces of it and guessing its way through. That works, but it's slow and inefficient.
So, they asked themselves, "What if we could make DQL find the best route by looking at the average direction to the destination?" That's the core idea behind their new approach called "One-Step Flow Q-Learning," or OFQL.
OFQL is like teaching our self-driving car to predict the overall flow of traffic. Instead of analyzing every single car movement, it learns the general direction everyone is heading and adapts accordingly.

OFQL uses something called "Flow Matching," which is like figuring out the average direction of a swarm of bees. Instead of tracking each bee individually, you just look at the overall flow of the swarm. By learning this "average velocity field," OFQL can directly generate the best action in one step! No more tiny lines, no more erasing, just one smooth, efficient motion! This means faster training and faster decision-making.
The really exciting part is that they tested OFQL on a bunch of standard benchmarks – think of it like giving it a driving test on a simulator – and it outperformed DQL and other similar methods. Not only was it better, but it was also significantly faster. That means we can train AI agents to do complex tasks in less time and with less computing power.
So, why does this matter?
For robotics folks: This could lead to robots that learn new skills much faster and can adapt to changing environments more easily. Imagine a robot that can quickly learn to assemble a new product on a factory floor.
For AI researchers: This provides a new way to think about decision-making and opens up possibilities for even more efficient algorithms.
For everyone else: This is a step towards AI that can solve complex problems more effectively, which could impact everything from healthcare to transportation to climate change.

Here are a few things I'm pondering after reading this paper:
Could OFQL be applied to areas outside of robotics and AI, like financial modeling or drug discovery?
What are the limitations of OFQL? Are there situations where DQL might still be a better choice?
How far can we push this "one-step" learning approach? Could we eventually develop AI that can learn and adapt in real-time?
That's all for this week's deep dive into the PaperLedge! I hope you found it as fascinating as I did. Until next time, keep learning, keep questioning, and keep pushing the boundaries of what's possible!Credit to Paper authors: Thanh Nguyen, Chang D. Yoo

Alright PaperLedge crew, Ernis here, ready to dive into something super cool that's pushing the boundaries of AI and how it interacts with our computers. We're talking about a new framework called ComputerRL, and it's all about giving AI agents the skills to navigate and master complex digital workspaces - basically, teaching them to use a computer like a pro!
Now, imagine trying to teach a robot to make a sandwich. It’s not just about telling it the steps; it’s about it understanding how to use the bread, the knife, the condiments – all the tools and interfaces. ComputerRL tackles the same problem but in the digital world. The researchers realized there's a big mismatch between how AI "thinks" (in code and APIs) and how we interact with computers (clicking buttons and using a mouse). So, they created this framework to bridge that gap.
The clever thing is something called the API-GUI paradigm. Think of it like this: the API is the direct line to the computer's brain, allowing the AI to do things with code. The GUI (Graphical User Interface) is what we see on the screen – the windows, icons, and menus. ComputerRL lets the AI use both! It can use code to do some things and then directly interact with the screen like a human would.
But here’s where it gets really interesting. To make these AI agents really good, they need a LOT of practice. The researchers wanted to train them using something called Reinforcement Learning (RL), which is like teaching a dog a trick: you reward it when it does something right. But training these AI agents is tough. It's like trying to train thousands of dogs at once in a really unstable environment! The problem is environmental inefficiency and instability in extended training.
To overcome this, they built a massive distributed RL infrastructure. Picture thousands of virtual computers all working together, letting the AI practice different tasks simultaneously. It's like having a huge training ground where the AI can experiment and learn at lightning speed!
Even with all that training, the AI can still get stuck in ruts. It’s like a student who memorizes the answers without really understanding the concepts. The AI can experience something called “entropy collapse”, where it stops exploring new options and gets stuck in a narrow range of actions. To fix this, they came up with a clever training strategy called Entropulse. It's like alternating between practice drills (reinforcement learning) and studying the textbook (supervised fine-tuning). This helps the AI stay flexible and explore new possibilities.
So, what were the results? Well, they used ComputerRL with some pretty powerful open-source AI models like GLM-4-9B-0414 and Qwen2.5-14B. And guess what? The model called AutoGLM-OS-9B achieved a new state-of-the-art accuracy of 48.1% on the OSWorld benchmark! That's a huge leap forward, showing that these AI agents are getting much better at general desktop automation.
Why does this matter?
For developers, it means a powerful new framework for building AI that can automate complex tasks.
For businesses, it opens the door to more efficient workflows and AI assistants that can handle a wider range of responsibilities.
For everyone, it represents a step towards more intelligent and helpful technology that can simplify our digital lives.

"The AutoGLM-OS-9B based on GLM-4-9B-0414 achieves a new state-of-the-art accuracy of 48.1%, demonstrating significant improvements for general agents in desktop automation."

This research has already been used to build AutoGLM, which is pretty cool. So, a few questions that pop into my head are:
How far away are we from AI assistants that can truly handle all our mundane computer tasks?
What are the ethical considerations of giving AI so much control over our digital lives?
Could frameworks like ComputerRL help bridge the digital divide by making complex software more accessible to everyone?
That's all for this episode! Hope you enjoyed diving into the world of ComputerRL. Until next time, keep learning and keep exploring!Credit to Paper authors: Hanyu Lai, Xiao Liu, Yanxiao Zhao, Han Xu, Hanchen Zhang, Bohao Jing, Yanyu Ren, Shuntian Yao, Yuxiao Dong, Jie Tang

Hey PaperLedge crew, Ernis here, ready to dive into some seriously cool AI research! Today, we're talking about keeping large AI systems on track, especially when they're working together like a team.
Imagine a relay race, but instead of runners passing a baton, it's AI agents passing information. Now, what happens if one agent makes a small mistake? That error can snowball, right? It's like a tiny typo in a document that gets copied and pasted everywhere, becoming a HUGE problem. This paper tackles that very issue: how to stop those AI relay races from going off the rails due to error propagation.
The researchers introduce something called COCO, which stands for "Cognitive Operating System with Continuous Oversight." Think of COCO as a super-smart supervisor, constantly watching over these AI teams to make sure everything's running smoothly. But here's the clever part: COCO doesn't slow things down! The system uses a decoupled architecture. This means that the error checking process is separate from the main workflow, keeping things running quickly. The paper claims it's like having a supervisor who can watch everything without adding any extra time to the task.
So, how does COCO actually work? It has three key ingredients:

Contextual Rollback Mechanism: Imagine you're writing a blog post, and you realize halfway through that you've made a mistake in the introduction. Instead of deleting everything and starting over, you just go back to the intro, fix it, and then continue. COCO does something similar. If it detects an error, it can rewind to the point where things went wrong, remembering what happened before, and then try again with better information.


Bidirectional Reflection Protocol: This is like having two editors reviewing each other's work. COCO has an "execution" module (the agent actually doing the work) and a "monitoring" module (the supervisor). They check each other, preventing the whole system from getting stuck in a loop of errors. This ensures that they move toward the correct answer.


Heterogeneous Cross-Validation: Think of this as getting a second opinion from a different doctor. COCO uses different AI models to check the work of the others. If they all agree, great! But if they disagree, it flags a potential problem, like a systematic bias or even an AI "hallucination" (where the AI just makes something up).

The researchers tested COCO on some tough AI tasks, and the results were impressive! They saw an average performance jump of 6.5%, which is a big deal in the world of AI. It basically sets a new standard for how reliably these AI systems can work together.
Why does this matter?

For AI developers: COCO provides a blueprint for building more robust and trustworthy AI systems.


For businesses: Imagine using AI to automate customer service or manage supply chains. COCO could help prevent costly errors and improve efficiency.


For everyone: As AI becomes more integrated into our lives, we need to ensure it's reliable and accurate. COCO is a step in that direction.

Here are a couple of questions that popped into my head while reading this:

COCO seems great for catching errors after they happen. But could it be adapted to predict potential problems before they even arise?


The paper mentions using diverse AI models for cross-validation. But how do you choose the right models to ensure you're getting a reliable second opinion?

That's all for this episode, crew! Hope you found this breakdown of COCO useful. Let me know what you think, and what research papers you want me to cover next!Credit to Paper authors: Churong Liang, Jinling Gan, Kairan Hong, Qiushi Tian, Zongze Wu, Runnan Li

Hey PaperLedge crew, Ernis here, ready to dive into some brain-tickling research! Today, we're looking at a paper that's trying to get Large Language Models – think super-smart AIs like ChatGPT – to become expert planners.
Imagine you're trying to pack for a trip. A specific plan would be: pack your toothbrush, pack your socks, pack your passport. But what if you wanted a generalized plan that works for any trip? Something like: "First, make a list of essentials. Then, gather those items and pack them in your suitcase." That's the kind of smarts this paper is after.
Now, traditionally, AI planners use something called PDDL – the Planning Domain Definition Language. It's a way of formally describing planning problems. This paper, however, is trying something cooler: getting LLMs to write Python code that automatically creates these generalized plans in PDDL. Think of it like teaching an AI to write a planning textbook!
So, how does it work? The researchers built on some previous work that had a three-step process:
First, the LLM gets a description of a planning problem (like the trip packing example) and writes a plain English summary and a possible packing strategy.
Then, the LLM translates that strategy into a Python program.
Finally, the program gets tested and debugged on example packing scenarios.
But here’s the problem: the old approach only generated one strategy. If that initial strategy was flawed, the whole thing would fall apart! It's like building a house on a shaky foundation.
This new paper adds some key improvements to make the process much more robust:
Pseudocode Debugging: Instead of directly writing Python code, the LLM first creates the strategy as pseudocode. Pseudocode is like a rough draft of the code, written in plain language. This allows the researchers to debug the strategy itself before it even gets translated into Python. Think of it as sketching out your blueprint before you start laying bricks.
AI Reflection: If the Python code fails, the LLM doesn't just give up. It's prompted to reflect on why the plan failed. It's like asking the AI, "Okay, what went wrong? Where did you mess up?" This helps it learn from its mistakes.
Multiple Attempts: Inspired by how LLMs generate code, the researchers have the LLM create multiple versions of the Python program. Then, they pick the best one. It’s like brainstorming multiple solutions and choosing the most promising.

"These extensions substantially improve (and never deteriorate) the quality of the generalized plans."

The results? In 12 out of 17 benchmark planning problems, their best Python programs solved all the tasks! That's a huge improvement.
So, why does this matter? Well, for AI researchers, it's a big step towards creating more autonomous and reliable planning systems. For businesses, it could lead to more efficient automation of complex tasks. And for the rest of us, it's just plain cool to see AI tackling challenging problems and learning from its mistakes!
Now, a few questions that popped into my head while reading this:
Could this approach be applied to other types of problem-solving beyond planning? For example, could an LLM learn to write generalized strategies for game playing or scientific discovery?
How much does the success of this approach depend on the specific prompts used to guide the LLM? Could cleverly designed prompts unlock even better performance?
Credit to Paper authors: Katharina Stein, Nils Hodel, Daniel Fišer, Jörg Hoffmann, Michael Katz, Alexander Koller

Alright PaperLedge crew, Ernis here, ready to dive into some seriously cool robotics research! Today, we're unpacking a paper about getting robots to work together, and not just in a simple, follow-the-leader kind of way, but in complex scenarios where they need to coordinate and strategize like a well-oiled machine – or, you know, a team of really smart humans.
Now, the traditional approach to teaching robots how to do things, called Reinforcement Learning (RL), is like training a dog with endless treats. The robot tries different actions, and if it gets closer to the goal, it gets a "treat" (a positive reward). But this takes a ton of practice data. Plus, it assumes the robot's next move only depends on its current situation, ignoring a potentially long history of what came before – think of it like forgetting everything you learned in the previous level of a video game. That's a problem when tasks require a memory of past events to succeed.
Enter Decision Transformers (DTs). Imagine instead of rewarding every action, you just show the robot a bunch of successful outcomes and say, "Hey, learn from these winning strategies!" DTs use fancy algorithms (specifically something called "causal transformers") to analyze these winning strategies and figure out the best way to achieve the goal. It's like learning from the highlight reel instead of watching every single play of the game. It's more efficient, but applying this to multiple robots working together is a challenge!
This is where the paper comes in. These researchers have developed something called a Symbolically-Guided Decision Transformer (SGDT). Think of it like giving the robot team a project manager. The project manager (the "neuro-symbolic planner") breaks down the overall task into smaller, more manageable sub-goals. Then, each robot (using a "goal-conditioned decision transformer") figures out how to achieve its specific sub-goal.
So, instead of one robot trying to figure out the entire complicated task, they're working together in a structured way. For example, if the task is to assemble a toy car, the project manager might tell Robot A to grab the chassis, Robot B to attach the wheels, and Robot C to secure the body. Each robot then uses its "DT skills" to figure out the best way to complete its individual task. It's a hierarchical approach – big picture planning at the top, detailed execution at the bottom.
“This hierarchical architecture enables structured, interpretable, and generalizable decision making in complex multi-robot collaboration tasks.”
The cool thing is, this SGDT approach seems to work really well, even in situations the robots haven't specifically trained for. The researchers tested it in "zero-shot" and "few-shot" scenarios, meaning the robots could adapt to new tasks with minimal training data. The researchers are saying that this is the first time that DT-based technology has been shown to be effective in multi-robot manipulation.
Why does this matter?
For robotics engineers: This provides a more efficient and practical way to deploy multi-robot systems in complex environments.
For AI researchers: It explores a novel combination of symbolic planning and transformer-based learning.
For the average listener: It brings us closer to a future where robots can collaborate to solve complex problems, from manufacturing and logistics to disaster relief and space exploration.
So, here are a couple of things I'm pondering after reading this paper:
How easily can this SGDT framework be adapted to different types of robots or completely new task domains?
What are the limitations of relying on a neuro-symbolic planner? Could it become a bottleneck, or introduce biases into the system?
That's all for this episode, PaperLedge crew! I hope you found this deep dive into multi-robot collaboration as fascinating as I did. Until next time, keep those gears turning!Credit to Paper authors: Rathnam Vidushika Rasanji, Jin Wei-Kocsis, Jiansong Zhang, Dongming Gan, Ragu Athinarayanan, Paul Asunda