Build a Multi-agent Content Creation System

Hands-on demo

​Build a multi-agent content creation system​

Lately, we have been experimenting heavily with ​Motia​, an open-source modern backend framework that brings together:

• Multi-agent orchestration
• APIs
• Event handling
• and background jobs…everything under one unified system.

The video below shows a demo where we have built a multi-agent content creation system that is also exposed via APIs.

Tech stack:

• ​Motia​ as the unified backend framework.
• ​Firecrawl​ to scrape web content.
• Ollama to locally serve Deepseek-R1 LLM.

Here’s the workflow:

• User submits URL to scrape.
• Firecrawl scrapes content and converts it to markdown.
• Twitter and LinkedIn agents run in parallel to generate content.
• Generated content gets scheduled via Typefully.

It’s easier to explain everything via video, so we have added one at the top.

It demonstrates building a multi-agent content creation system that is also exposed via APIs.

Just like React streamlines frontend development, Motia simplifies the AI backend, where you only need one solution instead of a dozen tools.

Key features:

• You can have Python, JS & TypeScript in the same workflow.
• You can deploy from your laptop to prod in one click.
• It has built-in observability & state management.
• It provides automatic retries & fault tolerance.
• It supports streaming response.

​​GitHub repo →​ (don’t forget to star it)

​You can find the code in this GitHub repo →

Hands-on

Tool calling in LLMs

Printing the response, we get:

Notice that the message key in the above response object has tool_calls, which includes relevant details, such as:

• tool.function.name: The name of the tool to be called.
• tool.function.arguments: The arguments required by the tool.

Thus, we can utilize this info to produce a response as follows:

This produces the following output.

This produces the expected output.

Of course, the above output can also be passed back to the AI to generate a more vivid response, which we haven't shown here.

But this simple demo shows that with tool calling, the assistant can be made more flexible and powerful to handle diverse user needs.

👉 Over to you: What else would you like to learn about in LLMs?

LLM fine-tuning

​Implementing DoRA (an improved LoRA) from scratch​​

We have covered several LLM fine-tuning approaches before.

​​​​DoRA​ is another promising and SOTA technique that improves LoRA and other similar fine-tuning techniques.

These results show that even with a reduced rank (e.g., halving the LoRA rank), DoRA significantly outperforms LoRA:

But why care about efficient LLM fine-tuning techniques?

Traditional fine-tuning is practically infeasible with LLMs.

To understand, consider this:

GPT-3, which has 175B parameters. That's 350GB of memory just to store model weights under float16 precision.

This means that if OpenAI used traditional fine-tuning within its fine-tuning API, it would have to maintain one model copy per user:

• If 10 users fine-tuned GPT-3 → they need 3500 GB to store model weights.
• If 1000 users fine-tuned GPT-3 → they need 350k GB to store model weights.
• If 100k users fine-tuned GPT-3 → they need 35 million GB to store model weights.

And the problems don't end there:

• OpenAI bills solely based on usage. What if someone fine-tunes the model for fun or learning purposes but never uses it?
• Since a request can come anytime, should they always keep the fine-tuned model loaded in memory? Wouldn't that waste resources since several models may never be used?

Techniques like LoRA (and other variants) solved this key business problem.

​DoRA​ further optimized this.

We did an algorithmic breakdown of how DoRA works and observations from LoRA that led to its development.

We also implemented it from scratch in PyTorch to help you build an intuitive understanding.

​​​​RAG​​​​ is powerful, but not always ideal if you want to augment LLMs with more information.

Several industry use cases heavily rely on efficient LLM fine-tuning, which you must be aware of in addition to ​building robust RAG solutions​.

​Learn and implement DoRA from scratch here →