# Eko

> JavaScript agent framework that turns one sentence into a multi-step workflow, in Node.js or the browser

- Category: Agents & Automation / Agent Frameworks & Builders
- Language: TypeScript
- Licence: MIT
- Repository: https://github.com/FellouAI/eko
- Website: https://eko.fellou.ai
- Canonical page: https://ai-tldr.dev/tools/eko/

## In short

Eko (pronounced like 'echo') is a JavaScript framework for building agents that go from a single natural-language instruction to a multi-step workflow. It sits in the Agent Frameworks & Builders category of the Agents & Automation tools and is open-source, written in TypeScript and licensed MIT. To get started: install the package.

## Overview

Eko (pronounced like 'echo') is a JavaScript framework for building agents that go from a single natural-language instruction to a multi-step workflow. Its distinguishing choice is the runtime target: rather than being a server-side Python library, Eko is pure JavaScript designed to run in both computer and browser environments — Node.js, a web page, or a Chrome extension — behind one unified interface.

A task is described in a sentence and planned into a workflow the framework executes, with agents composed from built-in pieces such as `BrowserAgent` and `FileAgent` or custom ones you define. Version 3.0 added dependency-aware parallel agent execution so independent branches run at the same time, plus pause, resume and interrupt controls with `task_snapshot` recovery; version 4.0 added chat conversations and reworked the agent logic.

Models are configured per-task as a map, so a workflow can mix providers — Anthropic, Google and any OpenAI-compatible endpoint including Qwen via DashScope or Doubao via Volcengine — and pick different models for different steps. MCP servers connect natively for tools, and human-in-the-loop hooks let a person intervene at the points that matter. The project warns explicitly against putting API keys in browser or front-end code: configure a backend proxy via `baseURL` and request headers instead.

## What it does

- Pure JavaScript, built for both Node.js and browsers — including Chrome-extension deployment
- One sentence to a multi-step workflow, with stream planning for dynamic rendering as the plan forms
- Dependency-aware parallel execution of independent agent branches (Eko 3.0)
- Pause, resume and interrupt controls with `task_snapshot` workflow recovery
- Multi-agent composition with built-in `BrowserAgent` and `FileAgent`, plus custom agents and tools in a line of code
- Dynamic LLM selection: a per-task map of providers, so different steps can use different models
- Native MCP support for connecting external tool servers
- Human-in-the-loop hooks to intervene mid-workflow

## Getting started

Eko installs as a set of npm packages and is driven from TypeScript. The repository ships three workspace examples under `example/` — a browser extension, a Node.js automation demo and a web login demo.

1. Install the package

   Add the core package to your project. The framework is published as `@eko-ai/eko`, with environment packages `@eko-ai/eko-nodejs`, `@eko-ai/eko-web` and `@eko-ai/eko-extension`.

```bash
pnpm install @eko-ai/eko
```

2. Configure models and run a task

   Define an `llms` map, pick your agents, and hand Eko a sentence. OpenAI-compatible providers such as Qwen or Doubao are configured through `provider: "openai"` plus a `baseURL`.

```ts
const llms: LLMs = {
  default: {
    provider: "anthropic",
    model: "claude-sonnet-4-5-20250929",
    apiKey: "your-api-key"
  },
  qwen: {
    provider: "openai",
    model: "qwen-plus",
    apiKey: "your-qwen-api-key",
    config: {
      baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
    }
  }
};

let agents: Agent[] = [new BrowserAgent(), new FileAgent()];
let eko = new Eko({ llms, agents });
let result = await eko.run("Search for the latest news about Musk, summarize and save to the desktop as Musk.md");
```

3. Keep API keys out of the browser

   The project flags this as a security warning: never put API keys in browser or front-end code, since it exposes your credentials. In web environments, route requests through a backend API proxy configured via `baseURL` and request headers.

4. Run the Node.js example

   From the repository root, install and build the core packages first, then run the Playwright-driven automation demo with at least one model key set.

```bash
pnpm install
pnpm build

cd example/nodejs
pnpm install
pnpm playwright install   # first time only, installs browsers
pnpm run build
OPENAI_API_KEY=... ANTHROPIC_API_KEY=... pnpm run start
```

5. Or load it as a browser extension

   Build the extension example, then load the generated `dist` directory through Chrome's developer mode. Configure your API key in the extension options before running a task.

```bash
cd example/extension
pnpm install
pnpm run build
# chrome://extensions → Developer Mode → Load unpacked → select dist/
```

## When to use it

- Browser automation and web scraping driven by a natural-language instruction rather than a hand-written script
- Shipping an agent inside a Chrome extension, where a Python framework cannot run
- Workflows whose independent steps should run in parallel, with the framework resolving the dependency graph
- Long-running automation that a person needs to pause, inspect and resume rather than watch run to completion