We’re excited to announce the launch of Tvara SDK v1 on PyPI 🎉 – your open-source toolkit to build agents and workflows without getting locked into a single vendor.

Whether you’re a student developer hacking at night, a corporate dev shipping fast, or an enterprise team scaling automation, Tvara gives you a clean, extensible way to connect models, tools, and workflows.

Why Tvara?

We’ve watched too many devs, from students to enterprises, burn hours fighting with agent frameworks.

• LangChain? Bloated boilerplate.

• LangGraph? Endless nodes and wiring diagrams.

All you wanted was an agent that just works.

Tvara flips that.

• Multi-LLM freedom → OpenAI, Claude, Gemini, whatever you prefer.

• Plug-and-play connectors → Gmail, Notion, GitHub, Salesforce, and more.

• Agents + Workflows out of the box → No over-engineering, no 50 lines of setup.

• Truly open-source → No vendor lock-in, no walls around your ideas.

Stop configuring graphs. Start building agents.

Who’s It For?

Students & Indie Devs

• Example 1: Build a personal study assistant that fetches lecture notes from Notion and emails you a summary every morning.

• Example 2: Create a mini research agent that scrapes GitHub issues + academic APIs, then formats insights into a doc automatically.

No more long boilerplates. Just mention your tools and you’re good to go.

Corporate Devs

• Example 1: Automate meeting scheduling: an agent that parses incoming meeting requests (emails), checks calendar availability, and suggests a slot back.

• Example 2: Build a CI/CD agent that comments on PRs by analyzing test results + code style.

Useful side-projects that save hours while making you look like the “AI guy” on the team.

Enterprises

• Example 1: Supervised workflow for lead intake — gather details from multiple sources (Salesforce + Slack + email), then auto-log into CRM.

• Example 2: Multi-step workflow that routes support tickets based on priority, fetches relevant docs, and escalates high-severity ones to Slack.

Secure, flexible, and works with your stack.

One Agent. One Workflow. Example

Agent Example

A Notion agent to fetch your data

from tvara.core import Agent

agent = Agent(
    name="My Notion Agent",
    model="gemini-2.5-flash", 
    api_key="your_model_api_key",
    composio_api_key="your_composio_api_key",
    composio_toolkits=["notion"],
)

response = agent.run("hey hi there. can you summarize 'Pondicherry - 2025' page for me?")

Workflow Example

A weather, poet and Gmail agent who takes the latest weather, creates a poem on it and emails it to users.

from tvara.core import Agent, Workflow, Prompt

weather_agent = Agent(
    name="Weather Agent",
    model="gemini-2.5-flash",
    api_key="your_model_api_key",
    composio_api_key="your_composio_api_key",
    composio_toolkits=["WEATHERMAP"],
)

poet_agent = Agent(
    name="Poet Agent",
    model="gemini-2.5-flash",
    api_key="your_model_api_key",
)

gmail_agent = Agent(
    name="Gmail Agent",
    model="gemini-2.5-flash",
    api_key="your_model_api_key",
    composio_api_key="your_composio_api_key",
    composio_toolkits=["gmail"]
)

manager_agent = Agent(
    name="Manager Agent",
    model="gemini-2.5-flash",
    api_key="your_model_api_key",
    prompt=Prompt(
        raw_prompt="You are a workflow manager coordinating multiple AI agents. Your job is to decide what should happen next."
    )
)

my_workflow = Workflow(
    name= "Sample Workflow",
    agents=[weather_agent, poet_agent, gmail_agent],
    mode= "supervised",
    manager_agent=manager_agent,
)

response = my_workflow.run("get the latest weather of sanfrancisco, write about it in a poetic way and send it to team@tvarahq.com on Gmail").final_output

Why v1 Matters

This is just the start. Tvara v1 brings a foundation: agents, workflows, connectors, multi-LLM. From here, we’re building towards truly reactive, supervised, deployable workflows!

Get Started

• PyPI

• GitHub

pip install tvara

We can’t wait to see what you’ll build. Tag us with your projects!

Contribute

Tvara is open-source, built with love, and we’d love for you to be part of its journey!
Whether you’re a seasoned developer or making your first ever open-source contribution, Tvara is a safe and welcoming space to learn, build, break, and improve together.

Here’s how you can start:

• Star the repo to show your support (it really helps us grow!)

• Spot a bug? Open an issue.

• Got an idea? Share it or send a PR.

• Improve our docs or add examples (every little bit counts!)

Remember, every contribution, no matter how small, makes Tvara better. You’re not just contributing code, you’re helping shape a tool that can impact how agents and workflows are built worldwide.

So jump in, experiment, and let’s build something amazing together!
Check out our CONTRIBUTING.md to get started.

In the last post, we explored what agents are and how they operate using tools and connectors. Now, it's time to build something with them: workflows - coordinated teams of multiple agents working together to accomplish a goal.

Workflows are end-to-end solutions designed to solve specific problem statements. Think of it this way: You want to buy an ice cream and deliver it to your friends at a park. One agent figures out the nearest ice cream shop, another places the order, a third handles the payment, and a fourth navigates the delivery route. Each agent handles a specific task, but together, they complete the full experience. That’s a workflow.

Visually, a workflow might look like this:

Types of Workflows

Hmm.. might look complex, but here’s the thing - in Tvara, we have statrted off simple by providing two types of workflows for devs - Sequential and Supervised.

1. Sequential Workflow: In this workflow, you define a series of agents that are tightly connected to each other, working together to solve a task step by step. The output of one agent becomes the input for the next like a chain reaction.

   Use this for basic, linear tasks where all agents share a common context. Be aware that since the context is passed along, there's a higher chance of hallucinations if the task drifts too far from the initial input.

   Example:
   An agent summarizes a long article → the next agent translates the summary into Hindi → another agent extracts key points from the translated version.

2. Supervised Workflow: Here, you define a supervisor agent, much like a project manager in a company. You assign a task to the supervisor, and it decides how to break it down, which agents are best suited to handle the sub-tasks, and how to coordinate everything.

   The supervisor collects results from the specialized agents and assembles them into a coherent final output.

   Use this for complex, collaborative tasks that benefit from domain-specific agents working independently under central coordination.

   Example:
   A user asks for a business strategy plan. The supervisor delegates tasks like market analysis, competitor research, and pricing suggestions to different agents, then compiles all the responses into a well-structured plan.

Creating Workflows with Tvara

Let us look at how easy it is to create workflows using Tvara. (For in-depth code understanding, I would suggest you to checkout the README.md on Tvara Repo.

Install Tvara using the following command:

pip install tvara

Sequential

Let’s create a sequential workflow where we want to research a topic and then write a blog based on that research.

from tvara.core import Agent, Workflow, Prompt
from tvara.tools import DateTool, WebSearchTool
import os
from dotenv import load_dotenv

load_dotenv()

# Step 1: Researcher Agent
researcher_agent = Agent(
    name="Researcher Agent",
    model="gemini-2.5-flash",
    api_key=os.getenv("MODEL_API_KEY"),
    prompt=Prompt(
        raw_prompt="You are a researcher tasked with gathering information on a specific topic. Use the tools available to you to find relevant information and summarize it.",
        tools=[WebSearchTool(api_key=os.getenv("TAVILY_API_KEY")), DateTool()]
    )
)

# Step 2: Blog Writing Agent
blog_agent = Agent(
    name="Blog Agent",
    model="gemini-2.5-flash",
    api_key=os.getenv("MODEL_API_KEY"),
    prompt=Prompt(
        raw_prompt="You are a blog writer. Use the information provided by the Researcher Agent to write a comprehensive blog post.",
    )
)

# Workflow definition
my_workflow = Workflow(
    name="Sample Sequential Workflow",
    agents=[researcher_agent, blog_agent],
    mode="sequential",
)

# Running the workflow
result = my_workflow.run("Write a blog post under the name of Tvara Community about the latest advancements in AI research.")

That’s it!
All we had to do was define the agents in the desired sequence - and done!

Supervised

Now, let’s create a supervised workflow where we want to:

1. Fetch the latest README.md of a GitHub repo

2. Summarize it

3. Send a message in a cheerful business tone to a Slack channel

Sounds complex? Let’s simplify it with Tvara:

from tvara.core import Agent, Workflow, Prompt
from tvara.connectors import GitHubConnector, SlackConnector
from dotenv import load_dotenv
import os

load_dotenv()

# Agent 1: GitHub Fetching
github_agent = Agent(
    name="GitHub Agent",
    model="gemini-2.5-flash",
    api_key=os.getenv("MODEL_API_KEY"),
    connectors=[GitHubConnector(name="github", token=os.getenv("GITHUB_PAT"))]
)

# Agent 2: Summarization
summarizer_agent = Agent(
    name="Summarizer",
    model="gemini-2.5-flash",
    api_key=os.getenv("MODEL_API_KEY"),
)

# Agent 3: Slack Messaging
slack_agent = Agent(
    name="Slack Agent",
    model="gemini-2.5-flash",
    api_key=os.getenv("MODEL_API_KEY"),
    connectors=[SlackConnector(name="slack", token=os.getenv("SLACK_BOT_TOKEN"))]
)

# Supervisor Agent
manager_agent = Agent(
    name="Manager Agent",
    model="gemini-2.5-flash",
    api_key=os.getenv("MODEL_API_KEY"),
    prompt=Prompt(
        raw_prompt="You are a workflow manager coordinating multiple AI agents. Your job is to decide what should happen next."
    )
)

# Supervised Workflow Definition
my_workflow = Workflow(
    name="Sample Workflow",
    agents=[github_agent, summarizer_agent, slack_agent],
    mode="supervised",
    manager_agent=manager_agent,
    max_iterations=3,
)

# Running the workflow
result = my_workflow.run(
    "Send the latest readme file of the tvara repository by tvarahq on GitHub to the Slack channel #test-channel. "
    "Ensure you send a summary only, written in a cheerful product launch business tone!"
)

And just like that, define a few agents, assign a manager… voilà!
The message appears in your Slack channel.

Attaching a screenshot of this cool result:

What’s Next?

Based off these examples, I would want to see more examples coming out from the community along with contributions that would help and improve the SDK itself.

In the next post, we would look into how these workflows work under the hood. This would add more clarity for developers to create their own workflows and contribute better!

Until then, Enjoy!