convez.ai
SkillAutomaçãoAvançado
jimhubrd

Personal AI Operating System

jimhubrd/personal-ai-operating-system

Arquitetura de IA pessoal em 8 camadas: ingestão até entrega com separação clara de responsabilidades

Ver no GitHub
InicialPluginScore · de 0 a 100

Um esqueleto genérico e pronto para uso que estrutura um sistema operacional de IA pessoal baseado em agentes Claude. Implementa uma arquitetura de 8 camadas: ingestão de dados, classificação, armazenamento, inteligência, agentes (Chief of Staff e diretores de domínio), skills, entrega e observabilidade. Estrutura modular para automatizar e organizar trabalho e vida pessoal sem custo proibitivo.

Instalação

$npx convez-ai jimhubrd/personal-ai-operating-system

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Construir um assistente pessoal autônomo com múltiplos agentes especializados
  • Automatizar coleta, processamento e análise de informações de múltiplas fontes
  • Gerar briefings, preparação de reuniões e relatórios personalizados automaticamente

Veredito

Uma estrutura sólida e bem documentada para quem quer construir sistemas de IA autônomos sofisticados. O modelo em 8 camadas é elegante e respeita o custo computacional; exige compreensão profunda de agentes e arquitetura para implementar efetivamente.

README

A tradução para o português deste README ainda está na fila.

Personal AI Operating System: Scrubbed Starter Skeleton

A clean, generic starting point for building a personal AI operating system on Claude Code: a Chief of Staff, a set of domain directors, a sparring council, a skills layer, and the data and automation layers underneath them. Everything personal has been removed. What is left is the shape, so you can drop your own life and work into it.

What This Is:

This is the structure, not the contents. The roles are archetypes, the skills are templates, and the layer docs explain how the pieces fit together. It is meant to be copied into a new project, renamed, and filled in. It assumes Claude Code with agents (subagents), skills, and MCP integrations, but the layer model applies to any agentic setup.

The Layer Model:

The system is eight layers. The bottom four move and shape information. The top four act on it. Keeping them separate is what makes the whole thing legible and cheap to run.

  1. Ingest: Scheduled pulls of raw signal from the places your life already lives (mail, calendar, chat, meeting transcripts, ticketing). Nothing here reasons; it only collects and lands raw material in one place.
  2. Classify And File: A cheap-model pass that sorts, dedupes, and routes what came in, so the expensive layers never wade through noise.
  3. Store And Memory: The persistent layer. A knowledge store (for example, a file per person or per project), a rolling summary the daily outputs read, and long-term memory that survives across sessions.
  4. Intelligence: Scanners that turn the store into signal over noise. This is where "what actually matters today" gets separated from "everything that happened."
  5. Agents: The actors that decide and delegate: a Chief of Staff at the top, domain directors who each own a lane, and a council of voices for stress-testing.
  6. Skills: The playbooks the agents run inline. Repeatable procedures, voices, and bodies of knowledge that load on demand.
  7. Delivery: The outputs a human actually sees: a morning brief, meeting prep and notes, reports. The only layer with a face.
  8. Observability And Resilience: The self-checks: reconcile what the system believes against what is real, meter cost, evaluate output quality, back up, and run a watchdog.

How The Layers Interact:

Signal flows up and actions flow down. Ingest drops raw material into the store. Classify and file makes it findable. Intelligence reads the store and flags what matters. An agent picks up a flagged item, calls whatever skills the task needs, and produces a delivery artifact. The observability layer watches all of it from the side and nags when reality and records drift apart. Crucially, agents do not each re-gather the world. They read a store that was already populated cheaply on a schedule. That single decision is most of why the system stays affordable.

Agents Vs Skills: How To Decide:

The test is one question: does it need its own brain, or is it a procedure?

Make it an agent if it needs its own context window, multi-step autonomy, the ability to delegate, or it persistently owns a domain. The Chief of Staff and the directors are agents because they decide what to do next.

Make it a skill if it is a repeatable procedure, a voice or writing style, or a body of knowledge that should run inside an agent that already exists. Writing a cover letter, prepping a meeting, running a verification pass, applying a brand kit: all skills.

The tell: if you find yourself spinning up a persona just to do one thing the same way every time, that is a skill wearing a costume. Collapse it. Not being attached to named characters makes the cuts easier and the system smaller.

Keeping It Lean: Token Practices:

These are the things that actually moved the needle, in rough order of impact.

  1. Skills Over Agents For Anything Procedural: A skill runs inline in an existing context. An agent spins up a whole new one. Procedures do not need a new brain.
  2. Defer Tool Schemas: Do not load every integration's tool definitions up front. Make them discoverable and load only when called. With many integrations, this is the single biggest context saver.
  3. Progressive Disclosure: Keep only a skill's name and one-line description in context. Load the full body only when the task triggers it. Dozens of skills then cost almost nothing at rest.
  4. Pin Models By Job: Rule-based work runs on the cheapest model, most work on the mid tier, and only genuine judgment runs on the top tier. Never let a job silently inherit a default.
  5. Schedule The Gathering: Let deterministic jobs do the repetitive collection so expensive reasoning only happens where it adds value.
  6. Prune On A Cadence: The system only ever wants to grow. Periodically retire the dead and merge the overlapping. Removing is as important as adding.

Folder Structure:

Scrubbed Starter Skeleton/
  README.md                         this file
  CLAUDE.md                         generic global-config template
  agents/
    chief-of-staff.md               the top coordinator
    director-template.md            copy once per life/work lane
    council-voice-template.md       copy once per sparring voice
  skills/
    example-skill/SKILL.md          the skill format, annotated
  jobs/
    README.md                       the ingest/delivery/observability pattern
  layers/
    LAYER-MODEL.md                  the eight layers in one place

How To Use This Skeleton:

  1. Copy the folder into a new location and rename it.
  2. Read CLAUDE.md and replace the bracketed placeholders with who you are and how you work.
  3. Pick your lanes. Copy director-template.md once per lane and name each director.
  4. Decide which of your repeated procedures become skills. Copy example-skill/SKILL.md for each.
  5. Wire the data layers last. Start with one ingest source and one delivery artifact (a morning brief is a good first one), then grow.

How To Adapt It To You:

Start small and let it earn its size. One Chief of Staff, two or three directors, a handful of skills, one scheduled brief. Add a layer only when the one below it is solid. The biggest mistake is building the full cast before the plumbing works.

What Is Deliberately Not Here:

No real names, no employer, no family, no financial or career detail, no live credentials, and no scheduling internals tied to one machine. Those are exactly the parts you supply. This skeleton gives you the bones; the life is yours to add.

Author And License:

Built by Jim Hubbard as a reference skeleton of a personal AI operating system. Released under the MIT License; see LICENSE. Forks and adaptation are welcome. This is a reference skeleton, not an actively maintained tool.

Ver o original no GitHub

Bom para

Relacionados