Trellis — Summary

Trellis is a team-scale AI coding harness from Mindfold that provides a trellis CLI (npm), a 4-phase workflow (Plan → Implement → Verify → Finish), auto-injected per-task specs via Claude Code hooks, and support for 14 AI coding platforms — making it the broadest multi-platform framework in this corpus.

Problem it solves: Team AI coding workflows break down because standards aren't shared, each developer rebuilds context per session, and the same specs must be repeated across tools; Trellis puts structured specs, task PRDs, and workspace journals in the repo so all team members and all AI tools share the same guidelines automatically.

Distinctive trait: Hook-injected spec context — a PreToolUse hook on Task/Agent tool calls intercepts every sub-agent dispatch and injects the relevant curated spec files from .trellis/spec/ and task JSONL context, so sub-agents always have the right guidelines without the user needing to prompt for them.

Target audience: Teams using AI coding tools (Claude Code, Cursor, Codex, Kiro, Gemini CLI, etc.) who want shared standards, per-task context injection, and workspace memory across 14 platforms.

Production-readiness: Active and growing (8,467 stars, 25 contributors, v0.5.19, last pushed May 2026, AGPL-3.0).

Differs from seeds: Closest to openspec (multi-platform, spec-per-feature, delta files) but Trellis adds a CLI binary, hook-based automatic spec injection, per-developer workspace journals, and explicit multi-platform support for 14 tools — vs openspec's npm-package + manual spec loading.

Trellis — Overview

Origin

Mindfold (mindfold-ai organization), released as an AGPL-3.0 npm package @mindfoldhq/trellis. Currently v0.5.19. 8,467 GitHub stars, 25 contributors. Active as of May 2026.

Philosophy

Trellis is named for a garden trellis — a structure that guides growth. The tagline is: "AI capabilities grow like ivy — Trellis provides the structure to guide them along a disciplined path."

The core philosophy: specs injected, not remembered. Rather than asking the AI to recall guidelines from memory or repeat them in every prompt, Trellis injects the relevant context files at the moment of sub-agent dispatch, via hooks. This creates a "set it and forget it" spec injection system.

Five core principles (from workflow.md):

1. Plan before code
2. Specs injected, not remembered
3. Persist everything — conversations get compacted, files don't
4. Incremental development — one task at a time
5. Capture learnings — review and write new knowledge back to spec

Key Differentiator

14 AI coding platforms supported: Claude Code, Cursor, OpenCode, Codex, Kiro, Kilo, Gemini CLI, Antigravity, Windsurf, Qoder, CodeBuddy, GitHub Copilot, Droid, Pi Agent. Setup:

trellis init --cursor --opencode --codex -u your-name

Manifesto-style quotes (from README)

"Make AI coding reliable at team scale."

"Specs live in the repo, so one person's hard-won workflow or rule can benefit the whole team."

"Personal workspace journals stay separate per developer, while shared specs and tasks stay in the repo where they can be reviewed and improved like any other project artifact."

Trellis — Architecture

Distribution

npm package @mindfoldhq/trellis. TypeScript + Python scripts.

Install

npm install -g @mindfoldhq/trellis@latest
trellis init -u your-name                    # basic init
trellis init --cursor --opencode --codex -u your-name  # multi-platform

CLI Structure

packages/
├── cli/                  # TypeScript CLI (Commander.js)
│   └── bin/trellis.js    # Entry point
│   └── src/commands/
│       ├── init.ts       # trellis init
│       ├── update.ts     # trellis update
│       └── uninstall.ts  # trellis uninstall
├── docs-site/            # Documentation site
└── guides/               # User guides

Project Directory Tree (after trellis init)

.trellis/
├── .version              # Framework version
├── .template-hashes.json # Template tracking
├── config.yaml           # Configuration
├── workflow.md           # Core workflow doc
├── agents/               # 3 sub-agents
│   ├── implement.md      # Code implementation agent
│   ├── check.md          # Code quality check agent
│   └── research.md       # Research agent
├── spec/                 # Coding guidelines (organized by package/layer)
│   └── {package}/{layer}/
│       ├── index.md      # Entry point with Pre-Dev Checklist
│       └── *.md          # Spec files
├── tasks/                # Task directories
│   └── {MM-DD-name}/
│       ├── prd.md
│       ├── implement.jsonl
│       ├── check.jsonl
│       ├── task.json
│       └── research/
├── workspace/            # Per-developer journals
│   └── {developer}/
│       ├── journal-N.md  # Max 2000 lines per file
│       └── index.md
└── scripts/              # Python utility scripts
    ├── task.py           # Task lifecycle management
    ├── get_context.py    # Context retrieval
    ├── add_session.py    # Session journaling
    ├── init_developer.py # Developer identity setup
    └── hooks/            # Hook scripts

.claude/                  # Claude Code integration
├── settings.json         # Hooks config
├── skills/               # 9 skills
│   ├── trellis-brainstorm.md
│   ├── trellis-implement.md
│   ├── trellis-check.md
│   └── ...
├── commands/             # Claude commands
│   └── trellis.md
├── agents/               # Claude agents (mirrors .trellis/agents/)
└── hooks/                # Python hook scripts

.cursor/                  # Cursor integration (if --cursor)
.codex/                   # Codex integration (if --codex)
.opencode/                # OpenCode integration
.pi/                      # Pi Agent integration

Required Runtime

• Node.js >= 18 (CLI)
• Python >= 3.9 (scripts + hooks)

Target AI Tools

14 platforms: Claude Code, Cursor, OpenCode, Codex, Kiro, Kilo, Gemini CLI, Antigravity, Windsurf, Qoder, CodeBuddy, GitHub Copilot, Droid, Pi Agent.

Trellis — Components

CLI Subcommands (binary: trellis / tl)

Skills (9, in .claude/skills/)

Sub-Agents (3, in .trellis/agents/ + .claude/agents/)

Hooks (3, in .claude/hooks/)

Python Scripts (.trellis/scripts/)

Commands (1, in .claude/commands/)

• trellis.md — Claude Code command for Trellis operations + finish-work

Templates

Task directory template: prd.md, implement.jsonl, check.jsonl, task.json in .trellis/tasks/{MM-DD-name}/

Trellis — Uniqueness

Differs from Seeds

Closest to openspec (multi-platform, per-feature spec folders) but with three structural advances: (1) Hook-injected spec context — PreToolUse on Task/Agent intercepts sub-agent dispatch and injects the right spec JSONL automatically (openspec uses manual spec loading); (2) Per-developer workspace journals — .trellis/workspace/{dev}/journal-N.md separates personal memory from shared specs (openspec has no per-developer memory layer); (3) CLI binary (trellis init/update/uninstall) for template management (openspec is npm install only). The 14-platform support is also unmatched in the seed corpus — nearest is superpowers which supports ~7 tools but fewer with native hooks. The explicit sub-agent model differentiation (minimax for implement/check agents vs Claude for orchestration) is a cost-optimization pattern seen in Tsumiki but not in seed frameworks.

Positioning

Trellis positions as "the best agent harness" (from repo description) and "make AI coding reliable at team scale" — targeting teams rather than individual developers. The team-shared spec system and per-developer journal separation directly address team coordination failures.

Distinctive Opinion

"Specs injected, not remembered" — encapsulated in the hook injection architecture. The JSONL context files curated during planning are the mechanism: rather than asking the AI to recall guidelines or loading all specs on every turn, Trellis precisely injects only the relevant files at the moment of sub-agent dispatch.

Observable Failure Modes

1. AGPL license: More restrictive than MIT — may block commercial embedding without license compliance review
2. Platform adaptation varies: Hook injection works natively in Claude Code; on other platforms (Cursor, Codex), spec injection may degrade to manual
3. minimax-m2.7 model: Sub-agents locked to a specific OpenRouter model — quality depends on that model's capability
4. Task.py Python dependency: Requires Python >= 3.9 for task management scripts
5. Team adoption overhead: Trellis adds significant structure overhead; solo developers may find it over-engineered