Model or dataset
TinyAGI/tinyagi avatar
TinyAGI/tinyagi

TinyAGI: a hosted dashboard driving a local API on port 3777

TinyAGI is the agent teams orchestrator for One Person Company. (fka TinyClaw)

3,632 stars505 forksTypeScriptMIT

At a glance

What is it?
TinyAGI orchestrates teams of AI coding agents over Discord, Telegram and WhatsApp with a SQLite queue and a browser dashboard. Its installer comes from the development branch, its version is still zero, and its default web interface is a remote page talking to your local API.
Who is it for?
TinyAGI suits someone who wants to drive coding agents from a chat app rather than a terminal, on their own machine, and who is comfortable with an agent loop holding their API keys. Four things to weigh first.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Activity is slowing. The repository last received commits 7 months ago.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 13, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • TinyAGI/tinyagi3,632 ★ · +11
Star history
Repository2026-09-242026-11-13
TinyAGI/tinyagi3.6k3.6k

11 Stars in the last 50 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

A zero series version, and two releases on the same afternoon

The package version is zero point zero point twenty, and the release list shows two tags published on the same date six hours apart, with a third two days earlier. So after a public existence the project has never left the zero series, and the recent cadence is several releases inside a few days rather than a slow drip. That is normal for something young and it is worth knowing before you pin it: a zero series signals that the author does not yet consider the interface settled, which is the same thing that makes it pleasant to try and risky to depend on. The repository also records its own rename, since the description says the project was formerly known by a different name, and the search terms around it show a cluster of similarly named projects, so check you are reading about this one and not its predecessor.

The installer comes from the development branch and chooses your provider

The whole installation story is one line:

bash
curl -fsSL https://raw.githubusercontent.com/TinyAGI/tinyagi/main/scripts/install.sh | bash

Three things are happening in it. A remote script is piped into a shell. The path it fetches from is the development branch rather than a release tag, so the installer tracks the tip rather than a version you chose. And running the installed command with no arguments does more than start a process: the page says it creates default settings, starts the daemon and opens the web interface, with no wizard and no configuration. Those defaults include a workspace path under your home directory, a default agent, and no chat channels at all until you add them. The default agent is specified as a particular vendor's model, so the zero-configuration path makes that commercial choice for you, and there is a separate interactive command for adding channels afterwards. That is a deliberate design for a first run, and it is the opposite of what you want if you are evaluating options.

The default dashboard is a hosted page driving an API on your machine

This is the part to read twice. The page tells you that once TinyAGI is running locally, you control it by visiting the project's own web domain, that this connects to your local API, and that no account or sign-up is needed. So the default interface is a page loaded from the internet whose job is to send requests to a service on your own machine, and that service is the one holding your provider keys and running your agents. For a browser to make those requests the local API has to permit cross-origin calls, and the page says nothing about how it authenticates the caller. There is a local alternative: a command that builds and starts the same interface on your own machine, on a different port, with an environment variable pointing it at your API. Nothing on the page frames the hosted option as a convenience with a security cost, which is the gap. If you use the default, understand what that page is allowed to reach.

The compose file publishes the API on every interface and mounts data at the container's home

The Docker path is short enough to read in full, and it has three choices worth noticing. The service publishes one port, the API port, with no bind address, so on a container runtime that means every interface rather than loopback, even though the page describes visiting it on your own machine. The named volume is mounted at the container's root home directory, which is where the workspace path and configuration land, so the data outlives the container by design. And the environment block passes two provider keys and two chat bot tokens, each with an empty default, which means they are visible in the container's environment and in whatever inspect output your tooling prints. There is no WhatsApp variable, which is consistent with that channel being linked by scanning a code instead. Between the port and the tokens, the compose file is the place to harden before you run this on anything but a laptop.

No lockfile in the repository, so the image resolves dependencies at build time

The root of the repository has no dependency lock file of any kind. That matters more than usual here because the container build is where dependencies get installed, and the build stage is written in a way that shows the omission is load-bearing rather than an oversight: it copies the root manifest and then each workspace manifest individually, sets an environment flag to skip a browser download, and runs a plain install. With no lock file to copy, that install resolves fresh from the registry every time the image is built. The build then prunes development dependencies and copies the resolved tree into the runtime stage, so whatever the registry returned that day is what ships. The same stage installs a native SQLite module, which is why it also installs Python, make and a C++ compiler before running the install. If you care about reproducing this image, or about what is inside it, that is the first thing to fix.

The agent CLIs are installed with their failures ignored

The prerequisites list four things: a supported operating system, Node, and one command line agent tool per provider. Those two agent tools are not optional extras, since without one of them there is no provider to talk to. In the container build they are installed globally, and the line ends with output suppressed and a fallback that makes failure succeed anyway. The next line does the same thing for a browser automation install. So if either of those installs fails, for a network reason or a registry change, the image still builds and still starts, and you find out when an agent cannot run rather than when the image is built. The same file also points the browser automation library at the system browser it installs itself, rather than downloading one, which is the right call and is done explicitly rather than by accident.

The development script starts four of seven workspaces

The root manifest is a workspace root, and the names in it tell you the shape of the system: a core, a teams layer, a channels package, a server, a main entry point, a command line package and a visualizer. Each has its own build script, and there are also start scripts for the main package, for the server, and separate ones for each chat channel inside the channels package. Now look at the single development script. It runs four workspace development tasks concurrently, under the names core, teams, server and main. The channels package and the visualizer are not among them. So `npm run dev` starts an instance with no Discord, Telegram or WhatsApp and no terminal dashboard, while both of those are headline features on the page. The per-workspace scripts exist, so this is a gap in the convenience command rather than in the tooling.

The dashboard is in the repository but is not a workspace

There is a directory at the root named for the web interface, and the page gives development instructions for it: change into that directory, install its dependencies, run its development server, and if the API is on a different host write its address into a local environment file. So the interface is a separate project with its own dependency tree. Meanwhile the root workspace pattern covers only a subdirectory of packages, and the root's own dependency list holds a single runtime entry, a cron library, plus four development dependencies. The interface is therefore neither in the root build, which is a single TypeScript project build across the packages, nor covered by the root install. That is a coherent monorepo-plus-frontend arrangement, but it means a contributor working on the interface has a separate install step that no root script performs, and the production container never builds it, since the interface is served from the project's own domain.

Editorial conclusion

TinyAGI suits someone who wants to drive coding agents from a chat app rather than a terminal, on their own machine, and who is comfortable with an agent loop holding their API keys. Four things to weigh first. The default browser interface is a page served from the project's own domain that connects to an API on your machine, so a local instance is being driven across the network boundary by default and there is a local alternative you have to opt into. The Docker compose file publishes that API on every interface and passes bot tokens and provider keys as environment variables. The installer is fetched from the development branch rather than a release, so what you install is whatever is at the tip. And the version is still a zero series with two releases published on the same day, which is the clearest signal of maturity available.

Frequently asked questions

What is TinyAGI?

A multi-agent, multi-team, multi-channel assistant that runs as a background process or container and lets teams of agents hand work to each other. It connects to Discord, Telegram and WhatsApp, keeps its queue in SQLite with atomic transactions, retry logic and a dead-letter path, runs agents in parallel, persists conversation context across restarts, and includes a browser interface for chat, agents, teams, tasks, logs and settings.

How do I install TinyAGI?

One command that pipes a shell script from the repository's development branch into your shell, after which running the installed command with no arguments creates default settings, starts the daemon and opens the web interface. There is also a Docker path using a compose file, a from-source path that clones and runs the same install script, and a development path that builds the packages and starts the tool directly. The stated prerequisites are a supported operating system, Node 18 or newer, and one agent command line tool per provider you intend to use.

What port does TinyAGI use and is it network reachable?

The local API is on port 3777, and the compose file publishes that port with no bind address, so on a container runtime it listens on every interface rather than only loopback. The page describes visiting it on your own machine. The web interface, by contrast, is served from the project's own domain and connects to that local API, with a command available to run the same interface locally on a different port instead.

Does TinyAGI need a Claude Code or Codex subscription?

It needs one command line agent tool per provider you use, listed as prerequisites alongside Node, and it supports two named providers plus custom endpoints compatible with either of their APIs. Key storage is handled for you, with tokens stored per provider so no separate command line authentication is needed. In the container image those two agent tools are installed globally with failures suppressed, so an install failure produces a running container with no agent rather than a failed build.

How mature is TinyAGI?

The published version is still in the zero series, and two of the three most recent releases were published on the same day. The repository was last pushed at the end of March 2026. The project also renamed itself, as its description records a former name, and the tree carries no dependency lock file, so a container build resolves dependencies fresh rather than from a committed set. Those four facts together are the honest maturity read.

Official sources

  1. License: MIT
  2. Project website
  3. README
  4. Releases
  5. TinyAGI/tinyagi on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/tinyagi-tinyagi.svg)](https://hysenlabs.com/projects/tinyagi-tinyagi)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/tinyagi-tinyagi.svg)](https://hysenlabs.com/projects/tinyagi-tinyagi)

Was this useful?