convez.ai
AgenteAutomaçãoAvançado
adamloucks1

Claude Agentic Ops

adamloucks1/claude-agentic-ops

Agent autônomo com governança de segurança para workflows de produção.

Ver no GitHub
InicialPluginScore · de 0 a 100

Um agent autônomo governado construído em Claude Code que executa rotinas agendadas e workflows automatizados sob uma camada de segurança e operações autoautorais. Implementa dois princípios críticos: checkpoints humanos antes de ações irreversíveis e processamento local de dados sensíveis, nunca enviando PII para APIs hospedadas.

Instalação

$npx convez-ai adamloucks1/claude-agentic-ops

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

  • Automação de tarefas repetitivas de conhecimento com aprovação humana
  • Gestão de dados sensíveis mantendo PII fora de APIs em nuvem
  • Orquestração de workflows que requerem checkpoints de segurança

Veredito

Implementação robusta e orientada à produção de governança de agents, não uma ferramenta plug-and-play. Particularmente valioso para cenários que exigem segurança real e conformidade em automação autônoma, embora requeira engenharia significativa para adaptação.

README

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

claude-agentic-ops

A governed personal agent built on Claude Code. It runs scheduled routines and automated workflows for my real day-to-day knowledge work, under a security and operations policy I wrote myself.

I work in cybersecurity and workforce program management. When I saw what agentic AI was becoming capable of, I didn't want to read about it, I wanted to operate it. So I built this: a production setup that handles the repetitive parts of my job. Nothing off the shelf existed for governing my own agents the way a security person would want them governed, so I wrote the governance layer too. That layer is the part of this repo worth reading.

This repository is a sanitized, generalized version of that system. All personal data, contacts, client material, and employer-specific content have been removed. What remains is the architecture and the governance.

The idea

Most "AI agent" demos show capability. The hard part isn't capability, it's the unglamorous process layer that makes an autonomous system safe to actually leave running. This repo is that process layer, extracted so it's reusable.

Two principles drive the whole design:

  1. A human checkpoint before anything irreversible or outbound. The agent does all the work up to the execution line, then stops and queues the action for me to approve. Drafting an email is fine; sending it is gated.
  2. Sensitive data never enters the model's context. Anything touching PII or confidential records is processed by a local model, never sent to a hosted API. The cloud agent orchestrates; local tools do the handling.

How it's organized

CLAUDE.md                  Top-level instructions the agent loads every session
.claude/rules/             The governance layer (the interesting part)
  security-gating.md         What the agent may never do autonomously, and the approval queue
  sensitive-data-local.md    Why and how sensitive data stays off the hosted API
  self-verification.md       Verify from the consumer's seat before delivering
  model-routing.md           Route work to the cheapest model that can do it well
  thought-partner.md         Make the agent disagree with me when it should
scripts/auto-resume/       A watchdog that resumes long work interrupted by usage limits

The governance layer

Security gating (.claude/rules/security-gating.md)

Defines categories of action the agent never executes on its own: anything leaving the machine bound for a person or the public, anything touching credentials, security-posture changes, destructive operations, and sensitive-data movement. When one comes up mid-workflow, the agent prepares it fully, writes the exact command or content to a verification queue, and continues. A gated step blocks only itself, not the whole run. Approval happens with me present. Unattended sessions queue only, even for actions that were approved before in a different context.

Sensitive data stays local (.claude/rules/sensitive-data-local.md)

Built on an honest constraint: anything the agent reads into context is transmitted to a hosted API. There's no setting that changes that. So the rule isn't "handle sensitive data carefully," it's "never ingest it at all." The agent writes and runs local scripts that do the actual processing, and any LLM work on raw sensitive data goes to a local model over localhost. The agent's context only ever holds file paths, schemas, row counts, and aggregate results.

Self-verification (.claude/rules/self-verification.md)

Anything a human will consume gets verified from the consumer's seat before delivery. Web output gets opened in a real browser and clicked through, not verified by reading the source. Slides get rendered and read as the audience. The target is to hand over 90 percent, not 70.

Model routing (.claude/rules/model-routing.md)

Frontier models are expensive. They're reserved for judgment and voice. Mechanical, well-specified work is delegated to cheaper models, with the frontier model reviewing the output before it ships. Cheap drafting, expensive review, not the reverse.

Thought-partner mode (.claude/rules/thought-partner.md)

A deliberate counter to the default people-pleasing failure mode. For planning and strategy work the agent is instructed to take a real position, disagree when it actually disagrees and say why, mark its confidence, and kill weak ideas early, including its own.

The auto-resume watchdog (scripts/auto-resume/)

Long autonomous tasks can outlive a usage window. An hourly scheduled task checks for a checkpoint file; if one exists, it launches a headless session to continue the work, and if not, it exits at zero cost. The agent writes the checkpoint at the start of any long task and updates it at each loop boundary, so a cutoff loses at most one step of progress. Resumed sessions run unattended, so they follow the security-gating rules strictly: queue gated actions, never execute them.

Why this exists

I built this for my own work, but the governance ideas are general. If you're running autonomous agents against real work, the capability is the easy 80 percent. The 20 percent that decides whether you can actually trust the thing is in .claude/rules/. That's the part I'd want a reviewer to read.


Built and operated by Adam Loucks. Sanitized for public release; no proprietary or personal data included.

Ver o original no GitHub

Bom para

Relacionados