agentic-ai-engineering/products/AGENT_PRODUCTS.md

TAC Agent Products

Build products as agent-run systems, not static templates. Each product packages TAC skills, course ideas, tests, deployment, and an operating loop.

Product Spine

Every product gets the same boring skeleton:

idea -> plan -> build -> test -> verify -> signed deploy -> observe -> improve

Runtime pieces:

• ADW pipeline for plan/build/test/review/ship.
• Verifier Pro before ship.
• Security Foundation around tools and deploy.
• Observability events for every action.
• Autoresearch/SkillOpt loop for measured improvement.
• Agent-native memory: events, claims, evidence, state cards, action outcomes.

Product Line

Product	User	Agent skills bundled	Runs on agents by
Product Factory	founders/builders	ADW, orchestration, verifier, deploy gates	turning ideas into shipped agent apps
Security Gate	teams with dangerous agents	L3-L5 security, prompt injection defense, sandbox	blocking unsafe commands and deploys
Verifier Pro	anyone shipping with agents	verifier, confidence ladder, claim decomposition	checking builder work every turn
SkillOpt Lab	agent-system owners	autoresearch, integrity guards, mutation ledger	improving skills only when evals pass
CEO Board	strategy/product decisions	CEO board, validator, tracker	adversarial decision memos and logs
Observability Cockpit	operators	tracer, cost tracker, replay, loop detector	showing what agents actually did
Multi-Agent Orchestrator	engineering teams	chains, teams, P2P, domain locks	routing work to specialists
Task Discipline	vibe-coders	tilldone, purpose gate, progress nudges	forcing defined tasks and completion
Agent Memory OS	research/factory users	evidence, claims, state cards, outcomes	recalling what worked and why
Local Model Gateway	privacy/resilience users	model routing, safety gate, local Kimi/Ollama	using local models without deploy authority

MVP: Product Factory

The first sellable product should be Product Factory because it contains the whole TAC thesis.

What it does

User submits product idea
  -> planner creates scope and acceptance checks
  -> builder creates minimal app/service/agent
  -> tester runs checks
  -> verifier grades claims
  -> deployer uses signed action API
  -> observer records evidence
  -> SkillOpt loop improves weak skills later

Included skills

• agent-chain for ADW phase flow.
• agent-team for specialist fanout.
• verifier-builder for read-only review.
• confidence-ladder for pass/fail grading.
• damage-control and l5-no-bash for safety.
• tool-call-tracer and session-replay for observability.
• experiment-loop, integrity-guard, median-over-best for self-improvement.
• tilldone and purpose-gate for task discipline.

Control plane

Use the existing engine factory:

• git-proxy / AI proxy: 8099 — primary signed deploy path: /deploy
• agent-site: 8084
• deploy-webhook: 8098 — legacy/internal fallback; do not call directly from TAC product flows
• Forgejo: 3030
• Qdrant: 6333
• Prometheus/Grafana: 9090 / 3001

Deploy must use signed actions, not raw shell.

Allowed actions:

run_skill_tests
patch_skill_from_pr
restart_container
rollback_container
disable_skill
enable_skill

Build Plan

Phase 1 — Catalog

Generate products/catalog.json from existing product READMEs and skill catalog.

Fields:

{
  "id": "product-factory",
  "name": "Product Factory",
  "skills": ["agent-chain", "verifier-builder"],
  "agents": ["planner", "builder", "reviewer", "executor"],
  "checks": ["pytest", "verifier"],
  "deploy_actions": ["patch_skill_from_pr"]
}

Phase 2 — Runner

Create one CLI:

python products/product_factory.py "build an agent-powered product"

It should only:

1. create a product folder,
2. write a spec,
3. run ADW pipeline,
4. record events.

No new framework.

Phase 3 — Evidence ledger

Add JSONL:

products/.events/YYYY-MM-DD.jsonl

Record:

• idea received
• plan written
• checks run
• verifier result
• deploy action requested
• outcome

Phase 4 — Dashboard

Static markdown first:

products/DASHBOARD.md

Show product status, last check, deploy readiness, and open risks.

Done Criteria

• products/catalog.json exists.
• products/product_factory.py creates a product spec from an idea.
• products/.events/*.jsonl records actions.
• uv run --with pytest pytest -q passes.
• No raw shell deploy path is introduced.

What Not To Build Yet

• No custom marketplace.
• No new graph DB.
• No giant web app.
• No autonomous agent spawning.
• No local Kimi deploy authority.

Ship the file-based factory first. Add UI only after the loop works.