Integrate AI agents into your existing TypeScript projects

Bring AI Agents into Your TypeScript Projects Without the Overhaul

You've seen the wave of AI agent frameworks, but most of them feel like you need to build your entire app inside their ecosystem. What if you could just... add an AI agent to your existing backend? That's the itch Suna scratches. It's a lightweight library that lets you integrate autonomous AI agents directly into your current TypeScript/Node.js projects, treating them like another service in your architecture.

It’s built for developers who want to experiment with or deploy agentic AI without rewriting their codebase or adopting a whole new framework.

What It Does

Suna is a Node.js library that provides a straightforward way to create and manage AI agents. You define an agent with a specific role and goal, give it access to tools (which can be your existing functions or API calls), and let it execute tasks autonomously. The agents run within your application, making them easy to control, monitor, and integrate with your current data and business logic.

Why It's Cool

The main appeal is the integration-first approach. Instead of building your app within an agent framework, you bring the agent into your app. This feels much more natural for existing projects.

Key features that make it stand out:

• Minimal Intrusion: It's a library, not a platform. You npm install it and start defining agents alongside your existing services.
• Tool Integration: Easily wrap your existing functions as tools for the agent. This means your agent can interact with your database, call your APIs, or trigger workflows you've already built.
• TypeScript Native: Built with TypeScript, offering the type safety and developer experience you'd expect in a modern TS project.
• Pluggable LLMs: While it comes with sensible defaults (like OpenAI), you can plug in different LLM providers, giving you flexibility over cost and performance.
• Simple State Management: It handles the agent's execution loop and context management, so you can focus on defining what the agent should do, not how it should run.

How to Try It

Getting started is a classic Node.js workflow.

1. Install it:

   npm install suna
   

2. Set your API key:

   export OPENAI_API_KEY='your-key-here'
   

3. Create an agent: Here's a quick example of an agent that can fetch and summarize news.

   import { Suna, Agent } from "suna";
   
   // 1. Initialize Suna
   const suna = new Suna();
   
   // 2. Define a tool (could be your existing function)
   const getWeather = {
     name: "get_weather",
     description: "Gets the weather for a city",
     execute: async (city: string) => {
       // Imagine this calls a real weather API
       return `It's 72° and sunny in ${city}.`;
     },
   };
   
   // 3. Create an agent with a goal and its tools
   const assistant: Agent = await suna.createAgent({
     name: "Research Assistant",
     goal: "Find and summarize information.",
     tools: [getWeather],
   });
   
   // 4. Run it with a task
   const result = await assistant.run("What's the weather like in Tokyo?");
   console.log(result);
   

Check out the Suna GitHub repository for the full documentation, more examples, and to contribute.

Final Thoughts

Suna feels like a practical step towards the "AI as a co-pilot in your app" future. It's not trying to be the most powerful or complex agent framework out there. Instead, it's a useful, no-nonsense tool for developers who want to add autonomous AI capabilities incrementally. If you have a Node.js backend and you've been curious about agents but didn't want to dive into a massive new paradigm, this is a great place to start experimenting. You could quickly prototype an internal research agent, a customer support triage bot, or an automated content organizer by leveraging the tools you've already built.

Follow for more cool projects: @githubprojects