# 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:

```text
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

```text
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:

```text
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:

```json
{
  "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:

```bash
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:

```text
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:

```text
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.
