# AGiXT: a Python agent platform with a 40-extension plugin system and a CLI-only install path

> AGiXT is an MIT-licensed Python platform for building and running AI agents against many model providers. The pip install is deliberately small; the full server, its Postgres, Redis and MinIO dependencies, and the 40-plus extensions are a separate opt-in.

**Josh-XT/AGiXT** — AGiXT is a dynamic AI Agent Automation Platform that seamlessly orchestrates instruction management and complex task execution across diverse AI providers. Combining adaptive memory, smart features, and a versatile plugin system, AGiXT delivers efficient and comprehensive AI solutions.

- Repository: https://github.com/Josh-XT/AGiXT
- Website: https://AGiXT.com
- Stars: 3,217 · Forks: 445
- Language: Python
- License: MIT
- Published: 2026-09-09 · Updated: 2026-09-09 · Language: en
- Canonical page: https://hysenlabs.com/projects/josh-xt-agixt

## The problem AGiXT targets: many providers, one agent surface

Most agent projects start as a thin wrapper around one vendor's chat API. AGiXT instead describes itself as a platform that manages instructions and executes tasks across several providers, with an adaptive memory and a plugin system. The stated audience is people wiring language models into things that already exist: smart home devices, enterprise workflows, chat channels, even crypto tooling. The topic list on the repository (agent-llm, llmops, chromadb, llama, llamacpp, openai) matches that framing.

That scope is the product's main selling point and its main cost. A project that wants to control a Tesla, read a PDF and answer on Slack has to carry dependencies for all three, and the dependency list confirms it: pdfplumber, playwright, pydub, opencv-python, pyzbar, pytesseract, solana, blinkpy, ring_doorbell, tinytuya, djitellopy and more sit in the same requirements.txt. If your agent only needs to call one model and return text, most of that file is dead weight.

## How AGiXT is put together: a server, a CLI, and a plugin layer

The repository layout shows the split. There is an agixt/ package directory, a ui/ directory, a Dockerfile, a docker-compose.yml, a docs/ directory, an examples/ directory and a tests/ directory. The compose file defines four services: postgres, redis, minio and agixt itself, with the agixt service pulling the image joshxt/agixt:main. Environment variables in that file wire the pieces together, including DATABASE_TYPE, DATABASE_HOST, DATABASE_PORT, REDIS_HOST, REDIS_PORT, STORAGE_BACKEND and STORAGE_CONTAINER. The default storage backend is s3, served by the bundled MinIO container.

The CLI is the entry point that most people will touch first. setup.py registers a console script named agixt pointing at agixt.cli:main, and it declares python_requires >=3.10. The examples directory includes notebooks for OpenAI and for a local model setup, plus scripts for websocket conversations and an MCP client, which suggests the supported integration surfaces are the HTTP API, websockets and MCP rather than a Python import of the agent loop. The README points to docs.agixt.com for provider configuration, authentication and extension development; the repository's own docs/ directory exists but the README defers to the external site.

## Installing AGiXT and running a first agent

The README gives a two-line quick start. The first command installs the package, and by default that is a small install: setup.py sets install_requires to a CLI-only list (python-dotenv, requests, websocket-client and pyotp). The heavy dependencies live behind an extra named local, which reads the full requirements.txt. So the quick start gets you the client, not the whole server stack.

```bash
pip install agixt
agixt start
```

What you should see after those two commands is the AGiXT service starting under the CLI. The README does not document the default port for `agixt start`; the compose file uses 7437 for the API (AGIXT_URI defaults to http://localhost:7437) and 3437 for the app, so check the CLI output rather than assuming.

If you want the full local server instead of the CLI, the extra is the documented path, and the compose file is the other one. The compose file expects a set of environment variables and falls back to defaults, so a minimal local run needs the database and cache services running first.

```yaml
services:
  agixt:
    image: joshxt/agixt:main
    environment:
      AGIXT_API_KEY: ${AGIXT_API_KEY:-None}
      AGIXT_URI: ${AGIXT_URI:-http://localhost:7437}
      DATABASE_TYPE: ${DATABASE_TYPE:-postgres}
      DATABASE_HOST: ${DATABASE_HOST:-postgres}
      REDIS_HOST: ${REDIS_HOST:-redis}
```

Note the default AGIXT_API_KEY of None. That is fine on a laptop and unacceptable on anything reachable from a network, so set the key before you expose the port. The compose file also mounts ./models/data into Postgres and ./s3 into MinIO, which means your agent state and files land in the repository working directory unless you change those paths.

## Where AGiXT gets in your way

The install story is the first friction point. A reader who runs `pip install agixt` and expects a working agent gets a CLI whose server-side dependencies are not installed; the local extra is the fix, but the README's quick start does not mention it. That is a documentation gap rather than a bug, and it will cost an hour to anyone who does not read setup.py.

The second is operational weight. Four containers is a real stack. Postgres, Redis and MinIO each need volume management, backups and upgrades, and the compose file's healthchecks only cover Postgres and Redis. MinIO has no healthcheck in the file shown, and it holds your workspace objects, so a MinIO that is up but not ready is a failure mode the compose file does not guard against.

The third is breadth as a liability. The requirements file pins specific versions of fast-moving libraries, including openai==1.44.0, anthropic==0.34.2 and google-generativeai==0.7.2. Provider SDKs change quickly, and a pinned set means upgrading one provider can force upgrades elsewhere. The README does not describe a rollback procedure, and the repository does not ship a documented downgrade path, so treat version bumps as a change you test in a staging copy of the compose file first.

Finally, AGiXT is the wrong tool if your agent is a single function call inside an existing Python service. Importing the platform to get one completion means running a database and an object store for no reason.

## AGiXT compared with a plain provider SDK or a minimal agent loop

The obvious alternative is the vendor SDK you already have, for example the openai or anthropic packages that AGiXT itself depends on. The difference is architectural, not cosmetic. With a raw SDK you own the conversation loop, the memory store and the tool dispatch, and you get exactly the dependencies you add. With AGiXT you get a server process, a REST and websocket API, a plugin registry and a memory layer, and you accept Postgres, Redis and MinIO as part of the deal. Neither is better in the abstract: the SDK wins when the agent is one component of a larger application, and AGiXT wins when several clients (a UI, a chat channel, a script) need to talk to the same agent state.

A second comparison point is the repository's own examples. The notebooks in examples/ show a conversational agent built through AGiXT's API, while examples/mcp_client_example.py shows the MCP client path. If your integration is already MCP-shaped, the platform's value is mostly in the memory and provider abstraction, not in the transport. Read that example before committing to the full stack.

## Licence, releases and what maintenance looks like

AGiXT is MIT licensed, and the LICENSE file sits at the repository root. MIT is permissive: you can use it commercially, modify it and redistribute it, provided the copyright notice and licence text travel with it. That matters here because the platform pulls in a long list of third-party packages, and those carry their own licences. MIT on AGiXT does not make the combined dependency set MIT, so a commercial deployment should audit requirements.txt rather than assuming the root licence covers everything. This is a description of the licence, not legal advice.

The release cadence visible in the repository is steady: v1.9.2 on 2026-03-15, v1.9.3 on 2026-03-26, v1.9.4 on 2026-04-08. The last push to the default branch was on 2026-07-28, which is within the last two months. The repository is not archived. Upgrade cost is dominated by the pinned dependency set and by database migrations, which the README does not describe; the compose file's Postgres volume at ./models/data is the thing to back up before pulling a new image tag, since the agixt service tracks the moving main tag rather than a version tag.

## Conclusion

AGiXT fits teams that want a self-hosted, MIT-licensed agent server with a plugin surface already covering chat, documents, smart home and blockchain, and who are willing to run Postgres, Redis and MinIO alongside it. It is the wrong pick if you want a single-process library with no external services, or if you need a documented rollback path between releases, because the README does not describe one. Before adopting, verify three things in your own environment: that `pip install agixt` followed by `agixt start` reaches a running service on the port you expect, that your chosen provider is one of the ones the provider configuration page lists, and that the extensions you need are covered by `requirements.txt`, since that file is what the `local` extra installs.

## FAQ

### What are the top 3 AI agents?

AGiXT is one of several agent frameworks, and the repository does not rank itself against others or publish a comparison list, so any top-three claim would come from outside this project's material.

### What are AGI examples?

The AGiXT README frames the project as an automation platform rather than an AGI implementation, describing 40+ built-in extensions and multi-provider support as its concrete features.

### What are the 5 types of AI agents?

The repository does not define an agent taxonomy. What it does document is how its own agents are configured: providers, instructions, adaptive memory and extensions, with the details on docs.agixt.com.

### Is AGI ChatGPT?

No. AGiXT is a separate MIT-licensed Python project that can call OpenAI and other providers, including local models, through its provider configuration.

## Sources

- [Josh-XT/AGiXT on GitHub](https://github.com/Josh-XT/AGiXT)
- [License: MIT](https://github.com/Josh-XT/AGiXT/blob/main/LICENSE)
- [Project website](https://AGiXT.com)
- [README](https://github.com/Josh-XT/AGiXT/blob/main/README.md)
- [Releases](https://github.com/Josh-XT/AGiXT/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/josh-xt-agixt