Open Source · Archived

v1 · MIT licensed

AEGIS

A self-hosted, flow-first personal AI orchestration platform

A small fleet of named agents run scheduled and event-driven Temporal workflows over your own data — tasks, email, money, knowledge, homelab alerts — and ask you for a decision only when they actually need one. Local-LLM-first and built to run on your own hardware. Version 1 is open source and now archived; version 2 splits it into separate products.

The v1 repo is archived: still public and readable, but it gets no more fixes or releases. What v2 is →

Read the v1 code★ 4How it worksRead the field notes

What it is

A careful backstage system, not a louder assistant

Every week there is another agent demo that promises to do everything. AEGIS is a smaller, stranger bet: that software can learn the shape of one person's life well enough to interrupt less. It watches the boring things — your tasks, your inbox, your money, your notes, the alerts from the machines in your house — and it only reaches for you when a decision is actually yours to make.

Version 1 was built to be forked and configured for your own life, not signed up for. There is no hosted version and no multi-tenant anything. You point it at your own accounts and your own models, and it runs on your own hardware. The value is not a product you switch on; it is a set of patterns — durable workflows, human-approval gates, personality-scoped tools, local-first inference — that you can read and reuse. The repo is now archived, so treat it as a reference, not a maintained project.

The AEGIS admin panel — a decision-first Overview screen showing pending decisions, alerts, agents and uptime
The Overview: what needs you right now, and how the system is doing.

How it works

A few ideas, applied consistently

None of these is novel on its own. The interesting part is what happens when you hold to them everywhere — one primitive for every decision, one durable engine for every job.

One primitive: interactions

Every time AEGIS needs you, it is the same shape — a row in Postgres, a card in your chat app, and a durable workflow waiting on your tap. Approvals, choices, drafts to review, plain acknowledgements: one mechanism, not a dozen.

Durable and flow-first

Every job is a Temporal workflow. Schedules, retries and multi-day waits survive restarts and deploys, and a change to a schedule takes effect without a redeploy.

A small fleet of agents

Named agents — Sebas for tasks, Raphael for research, Maou for money — each a permission boundary with its own tools, model tier and voice. A fourth, Pandora’s Actor, ran the infrastructure until that lane moved to v2.

Behaviour is data, not code

Agents key on capability tags, not identity. Rename them, re-scope them, or add your own from an admin page — without touching a line of Python.

GTD at the centre

Todoist is the canonical task store, mirrored every five minutes. Work-streams are labels, the inbox gets clarified automatically, and the system asks before it acts.

Local-LLM-first

A LiteLLM proxy resolves fast / balanced / smart tiers to whatever models you point it at, reaching for a hosted model like Claude only when a job wants more horsepower.

Your knowledge as infrastructure

A native Postgres + pgvector retrieval store the agents can search and cite, seeded from your own URLs, uploads and folders. No separate service to run.

Runs on your own hardware

FastAPI, Postgres and Temporal on a small Docker Swarm at home — not a cloud region, not a SaaS. You bring your own credentials and your own models.

The AEGIS admin panel — the agent fleet: Sebas, Raphael, Maou and Pandora's Actor
The fleet as it ran in v1: four agents, each a permission boundary with a name.
The long version: what runs, what it may do alone, and where you sit in the middle
TemporalFastAPIPostgres + pgvectorLiteLLMReactDocker Swarm

Quickstart

Running v1 in one command

The repo is archived, so nothing in it will be patched, including security issues. Run it to learn from it, not to put it in front of real accounts unreviewed.

Docker Compose brings up Postgres + pgvector, Temporal, and the core API and worker. Everything after that — models, agents, flows, integrations — is configured in the admin panel, not in YAML.

git clone https://github.com/hikmahtech/aegis.git && cd aegis
cp config/.env.example config/.env   # set admin username / password
docker compose up -d                 # core (:8080) + worker + postgres + temporal

Then open http://localhost:8080, point it at a hosted key or a local model, and switch on the flows you want. Full setup notes in the README.

The story so far

Field notes from building it

AEGIS was two rewrites in before any of this, and private for most of its life. These are notes from the build — from the ten days of turning something that worked for me into something you can fork, and now from splitting it into v2.

AEGIS v1 is archived. Here is what replaces it

I'm archiving the open-source AEGIS repo. Version 2 splits one system that did everything into separate products on a shared SDK, each with its own database and deploy. Why, what is live, and what happens to the old code.

AEGIS Is Open Source

Three months ago I wrote about my personal AI orchestration system and ended with a section titled 'Why It's Not Open Source Yet.' That's fixed. AEGIS is on GitHub, MIT-licensed — here's what it actually took to get there.

Behavior Is Data, Not Code

The biggest refactor of the AEGIS open-sourcing sprint: removing every branch on an agent's identity so behavior lives in the database as capability tags — resolved at runtime, edited from a UI, and safe even when a tag has no owner.

A To-Do Is a Tweet: Social Publishing With Approval Cards

Scheduling a social post doesn't need a new UI. A to-do already has copy, a time, and labels — so in AEGIS, a Todoist task with a publish label is a scheduled post, and nothing goes out until a card in chat gets a human tap.

Bring Your Own Cloud: The Infrastructure Registry

For a self-hosted system that's meant to be forked, there's exactly one honest way to handle infrastructure credentials: the user brings their own, the system stores them encrypted, and nothing in the code assumes a vendor. Here's how AEGIS got there — and what it cost me to cut my own vendors out.

Labels, Not Projects: Rethinking GTD

The day Next and Someday stopped being Todoist projects and became labels — and why that small modelling decision is what made AEGIS's GTD layer, and its bidirectional sync, actually work.

Day One of Opening the Box

AEGIS is going open source, and today the first public commits landed. Day one of turning a private system into a shippable one: twenty-seven migrations squashed into a baseline, credentials evicted from the build, and an admin panel redesigned around decisions.

When the Bot Learns to Stay Quiet

AEGIS watches my homelab and GitHub, but the interesting part is what happens between an alert firing and me hearing about it. Most of the time, the correct answer is nothing.

One Primitive for Every Interruption

The design decision in AEGIS I'm proudest of isn't an agent or a model — it's a single interactions primitive. How one Postgres table, five kinds of card, and a Temporal workflow replaced every per-domain approval pattern.

Meet AEGIS: My Weird Little Operating Layer

AEGIS is my personal operating layer: four agents that watch my inbox, repos, alerts and feeds, and bring a proposed next step instead of a notification.

What comes next

AEGIS v2: the same ideas, split into products that each stand on their own

Version 1 was one system doing everything for one person. That made it quick to build and hard to hand to anyone else: the accounting code and the homelab code shared one database, one worker and one deploy.

Version 2 splits it. Each area becomes its own product with its own database, worker, API and deployment. The products share one SDK and two running services, the Temporal cluster and the LiteLLM proxy, and nothing else. The ideas stay the same: one approval primitive for every interruption, durable workflows, local-first models, and an audit line for every action that matters.

Books: live

Bank statements in, reconciled, and posted to a plain-text hledger journal. Anything it is unsure of becomes an approval card. Built for solo founders and small firms in India; live on my own books since October 2026.

DevOps: live

Alert intake, investigations and typed fixes for my homelab. It ran in shadow beside v1 until the cutover on 8 October 2026. Every fix beyond one automatic restart waits for my approval.

Assistant, research, development: first steps

Tasks, a searchable knowledge library, and repo triage each have a first milestone live. Each picks up an area v1 used to run.

The code is private

v1 stays public as the reference for the patterns. v2 is where the products are, so its code is not open source.

I shut v1 down on 8 October 2026, once Books and DevOps were live. Areas that have no v2 product yet are paused until theirs is built. I will write up each step on the blog: what moved, what broke, and what the split cost.

If one of these products fits a problem you have, or you want the same pattern built on your own data, I'd like to talk.

Book a callEmail me

Take it apart, or have one built

The v1 code stays open and readable, so you can see exactly how the approval gates work. And if you want a careful, durable automation system like this built for your own business, that is the kind of work I do.

Have one builtRead the v1 code

Weighing up an AI workflow of your own first? Run the 17-question AI workflow teardown →