Way of Teams is the AI engineering harness for modern teams. It combines tickets, standups, skills tracking, AI agents, and observability in one real-time workspace.

Quick Start

1. Sign Up — Create your account in one click with GitHub, Google, or Apple
2. Redeem Access Code — Enter your invite code to activate your account (alpha access required)
3. Connect Your Tools — Link GitHub and Google for full functionality (see below)
4. Start Working — Create tickets, run standups, and let AI agents help your team

Complete Setup — Connect Your Accounts

For full use of Way of Teams, you need to connect your external accounts. This enables AI agents to work with your code, calendar, email, and documents.

Connect MCP to Your AI Tools

To use Way of Teams with your AI coding tools, connect the MCP server. This gives your tools access to tickets, plans, docs, kanban, knowledge, and memory.

Quick Connect (Recommended)

1. Get your token — Go to Settings → MCP in Way of Teams and copy your API token
2. Add to your tool — Paste the token into your AI tool's MCP configuration
3. Start using — Your tool now has access to all 217+ MCP tools

Supported Tools

Two Ways to Connect

Use them together — for example, OpenCode + Ollama gives you a fully local setup.

See MCP Server section below for detailed setup instructions.

What You Get After Setup

• 53 Battle-Tested Skills — Auto-ticket creation, backlog grooming, GitHub automation, PR reviews, postmortems, runbooks, and more
• 12 Specialist Agents — Codebase analyzer, locator, pattern finder, thoughts analyzer, web researcher, coder, planner, reviewer, scout, and more
• 5 Unified Commands — /create-plan, /implement-plan, /validate-plan, /commit, /debug — consistent workflow across all platforms
• 217+ MCP Tools — Full API access to tickets, plans, docs, kanban, knowledge, rules, and memory

Works identically across OpenCode, Claude Code, Codex, Antigravity, Pi, and Wo Code — one harness, every tool.

Way of Teams is currently in alpha, and a redeemable access code is required to use the platform. If you're a beta/alpha tester, here's how it works.

What is an access code?

An access code is an invite that grants you access for a fixed period — 1, 2, or 3 months. You'll receive a code that looks like XXXX-XXXX-XXXX from a Way-Of team member.

How to redeem your code

1. Sign in — Go to the sign-in page and sign in with GitHub (or your configured provider).
2. Find the redeem box — Once signed in, you'll see a "Redeem access code" section on the sign-in page.
3. Enter your code — Type or paste your code (e.g. FJ9K-2YPL-QWER) and click Redeem.
4. You're in — Access is active immediately. The page confirms your access-until date.

What happens when it expires?

When your access period ends, you'll see an "Access Expired" screen with a redeem box. Enter a new code to regain access, or reach out for a renewal. You won't lose your data — access simply pauses until you redeem again.

Alpha perks

• Early access — You're using Way of Teams before it's public.
• Free during alpha — No payment needed. Codes manage the alpha cohort.
• Shape the product — Your feedback directly drives what we build.
• Team codes — Some codes are shareable (multi-seat), others are single-use. We'll tell you which you have.

Questions or need a code? Reach out to your Way-Of contact — they can generate one in minutes.

Way of Teams is built with Elixir on the Ash Framework with:

• Phoenix LiveView for real-time UI
• AshPostgres for data persistence
• AshPhoenix for Phoenix integration
• AshJsonApi for REST APIs
• Ash Authentication for identity & access
• Oban for background job scheduling
• OpenTelemetry for observability
• Jido (Jido AI, Jido Signal, Jido Action, Jido Studio) for AI agent orchestration
• Bandit as the HTTP server
• Swoosh for email delivery
• OpenApiSpex for OpenAPI spec generation
• Astro for the documentation site

Services

• Node.js Chat Server — real-time messaging via Express + WayOfMono
• PostgreSQL 16 — primary data store
• Podman — container runtime (compose + quadlets)
• Docker — alternative container builds
• Cloudflare Tunnel — production routing & edge

Core Domains

• Accounts — Developer management
• Tickets — Issue tracking with status workflow
• Skills — AI tool skill management
• Standups — Daily standup tracking
• Notifications — System notifications
• Insights — Skill reports and analytics
• Kanban — Visual project management
• Frrd — Change tracking for f-rr-d

AI Engineering Harness

Explore the full catalog of skills, agents, and commands:

• AI Harness Repository
• f-rr-d Thoughts Repository

Community & Support

• GitHub Issues for bug reports and feature requests
• GitHub Discussions for questions and ideas
• Enterprise support available on Team and Enterprise plans

                ┌─────────────────────────────────────────────────────────────┐
                │                  YOUR WAY-OF JOURNEY                        │
                │                                                             │
                │  1. What do you want to do?                                │
                │  2. What do you want to name it?                           │
                │  3. Connect your AI tool (Teams MCP / harness).            │
                │  4. Let's make two repos based on the name.                │
                │  5. Let's make your first ticket.                           │
                │  6. Let's implement your first ticket.                      │
                │  7. Look at what you just did.                              │
                │  8. Let's create your next tickets.                         │
                │                                                             │
                │              ──→ You're building now.                       │
                └─────────────────────────────────────────────────────────────┘

Step 1 — What Do You Want To Do?

Every project starts with a question: "What problem are you trying to solve?"

• Problem statement (even a rough one)
• Who it's for
• What success looks like

We capture it as a structured ticket, break it into actionable pieces, and prioritize by impact.

Step 2 — Name Your Project

Your project gets a unique identity that defines your team's workspace.

• Project Name — e.g., "teams" becomes your Way of Teams instance
• Ticket Namespace — All tickets follow the format: WOTEAMS-XXX

Step 3 — Connect Your AI Tool

Your skills live in the Teams MCP server — so once your AI tool is connected to WayOfTeams, every skill, agent, and command is available in it directly. No separate harness install is needed when you use the Teams MCP. If you prefer to work without the MCP, the same skills ship as the standalone ai-harness CLI — the choice is yours.

Step 4 — Create Two Repos

You create two repos for your project:

• Code repo — your app, tests, and configs
• Thoughts repo (f-rr-d) — tickets, plans, research, and docs

One Thoughts repo can serve all of your projects — tickets, plans, and docs from every codebase you work on live in the same f-rr-d repo.

Step 5 — Create Your First Ticket

Your ticket follows a standardized format that AI agents can process:

• Problem Statement — What problem are you solving?
• Desired Outcome — What does success look like?
• Acceptance Criteria — How do we know it's done?

Step 6 — AI Agents Build It

• /create-plan — Turn your ticket into a step-by-step implementation plan
• /validate-plan — Check feasibility, dependencies, and risks before building
• /implement-plan — Execute each phase with automated testing and commits
• /commit — Well-structured git commits ready for review

Agents: Planner → Coder → Reviewer → Debugger

Step 7 — See It Working

Your feature is live on your team's dashboard. The ticket status updates to "Done" automatically. Git history shows exactly what was built and when.

Step 8 — Keep Building

The flywheel spins: Tickets → Harness → Working Software → Learning → More Tickets

Dark-themed, single-page-app style, everything one click away. Sidebar with 18 links, sticky header with org switcher, real-time notifications, embedded AI chat panel.

Sidebar Navigation

☰  Dashboard        📋  Standups
🎫  Tickets          🤖  AI Chat
📋  Kanban           💬  Team Chat
📊  Skills           💡  Ideas
✅  Review Queue     📰  News
👥  Developers       🔧  Admin
⚙  Settings         👤  My View
📄  Docs             🔗  F-rr-d Changes

• Dashboard — Command center with stats, tickets, standups, AI chat
• Tickets — Full management with filters, search, bulk ops, activity timeline
• Kanban — Board/List/Calendar views, drag-and-drop, real-time sync
• Standups — Daily check-in with history and focus scores
• AI Chat — Streaming, thinking blocks, per-session settings, 30+ providers
• Team Chat — Real-time messaging, video calls, AI meeting notes → tickets/kanban/plans
• Ideas — Submit, vote, prioritize, discuss, status workflow
• News — Announcements with read tracking
• Review Queue — Lead-only view with Approve/Request Changes/Reject
• My View — Personal dashboard with stats and quick actions
• Admin — Team management, activity dashboard, Jido Studio, f-rr-d sync

You sign up. You talk. It builds.

1. Sign Up — One click, GitHub/Google/Apple
2. Join the Meeting — Video call in Way of Teams
3. Way of Teams Listens — AI absorbs: decisions, tasks, dependencies, priorities
4. After the Meeting — AI goes to work
5. You Come Back To — Kanban board, Tickets, Plan, Assignments, Standup summary
6. You Review. You Adjust. You Go.

Every AI coding tool — Claude Code, OpenCode, Codex, Pi, wocode, and the rest — runs the same AI Engineering Harness. Everything the harness does lands in Way of Teams, where you and your team can see it.

You can see what your own tools are doing

• In the terminal — the harness tells you exactly what it's doing: reading files, running commands, creating tickets, committing changes.
• In the UI — every action is captured: tickets created, plans written, commits pushed, sessions exported — nothing happens invisibly.
• On the dashboard — step back any time to review the full trail of what was built, when, and by which tool.

Your team can see what everyone's tools have done

• Shared workspace — each teammate's coding tools publish their work: tickets, standups, skill activity, review queue, kanban moves.
• One view for leads — leads and admins see all AI activity across the team — no more "what did Claude do today?" guessing.
• Real-time notifications — surface the important moments, and standups are generated automatically from git and ticket history.

AI work becomes transparent, reviewable, and trackable — for the person doing it and for everyone around them.

Way of Teams is where your people and their work come together. It combines team management, visual project tracking, and scheduling in one real-time workspace.

Team Management

• Developers — Manage team members, roles, and permissions. Invite by email or through GitHub OAuth.
• Admin — Team management, activity dashboard, and integration controls (Jido Studio, f-rr-d sync).
• Standups — Daily check-ins with history and focus scores, generated automatically from your work.
• Notifications — Real-time alerts for tickets, reviews, and AI activity across the team.
• Team Chat — Real-time messaging, video calls, and AI meeting notes that turn conversations into tickets and plans.

Kanban

• Board view — Drag-and-drop cards across statuses with real-time sync for everyone on the board.
• List view — See every ticket in a clean, filterable list with search and bulk operations.
• Calendar view — Schedule work, standups, and releases on a shared calendar.
• Cards are tickets — the same work shows up in dashboards, standups, and reports.

One Engine for Every Niche

Way of Teams turns the kanban engine into a universal work engine — the same boards, columns, MCP tools, notifications, and AI serve every kind of work:

• Software work & coding — tickets, plans, PR reviews, and releases, tightly coupled to GitHub and f-rr-d.
• Personal tasks & private boards — per-developer "My Boards" that are invisible to teammates, with an Inbox for quick capture, file attachments, recurring reminders, and a Today view.
• Marketing planning — content calendar (Idea → Writing → Editing → Scheduled → Published) and campaign tracker boards, AI content drafts, and marketing knowledge.
• Sales pipeline — Lead → Contacted → Qualified → Closed boards for deals and follow-ups.
• Company strategy — a dedicated company board moving Vision → Mission → Initiatives → Quarterly OKRs → KPIs, with AI OKR drafting and KPI tracking cards.

Every board template column — including niche ones like writing, published, lead, quarterly_okrs, and achieved — is validated and movable end-to-end via the MCP tools and the UI.

Sharing & Scoping

• Scopes — boards are tagged work, private, marketing, sales, or company; private boards are visible only to their owner.
• My Boards — a board picker with niche tabs and an owner-scoped "My Boards" section.
• Member roles — share a board with specific developers as owner, admin, member, or viewer; only owners and admins can share or change visibility.
• Attachments — cards can carry file attachments in every niche (UI and MCP).

Calendar

• Shared calendar — See deadlines, meetings, and planned work on one calendar.
• AI meeting notes — create tickets and schedule follow-ups automatically.
• Standups & releases — Track them alongside your team's deliverables.

Way of Teams turns its kanban engine into a universal work engine. The same boards, columns, MCP tools, notifications, and AI now serve every kind of work your team does — not just software tickets. There is no second app, no second login, and no second database: every niche gets its own boards, columns, and space, scoped to you or your company.

The Niches

• Software work & coding — tickets, plans, PR reviews, and releases, tightly coupled to GitHub and f-rr-d. This remains the "work" niche, and the AI Engineering Harness runs at full depth here.
• Personal tasks & private boards — a per-developer "My Boards" space with private boards invisible to teammates. Quick-capture inbox, file attachments, recurring reminders, and a Today view.
• Marketing planning — content calendar and campaign tracker boards (Idea → Writing → Editing → Scheduled → Published, and Planning → … → Live → Analysis), AI content drafts, KPI cards, and searchable marketing knowledge.
• Sales pipeline — Lead → Contacted → Qualified → Closed boards for deals and follow-ups, with AI-assisted outreach and KPI tracking.
• Company strategy — a dedicated company board moving Vision → Mission → Initiatives → Quarterly OKRs → KPIs, with AI OKR drafting from your mission and KPI tracking cards.

Boards Carry Scope & Ownership

Every board is tagged with a scope — work, private, marketing, sales, or company — and may carry an owner.

• My Boards — the board picker shows niche tabs plus an owner-scoped "My Boards" section.
• Truly private boards — a private board is visible only to its owner; nobody else in the company sees it (UI and MCP).
• Sharing with roles — owners and admins can share a board with specific developers as owner, admin, member, or viewer.
• Visibility — a board can be switched between private and company visible.
• Attachments everywhere — cards in every niche accept file attachments, both in the UI and through the MCP tools.

Every Template Column Works End-to-End

There are 35+ unique column IDs across all board templates (Software, Project Management, Marketing, Sales, Personal, and the new Company templates). Column IDs are de-duplicated and validated:

• Column validation on move — kanban_card_move checks the target column exists on the board and returns a clear error instead of silently moving a card to a nonexistent column.
• Graceful status sync — niche columns with no matching ticket status (ideas, writing, scheduled, published, achieved, lead, closed_won, quarterly_okrs, initiatives, …) keep the card's existing status or fall back to the board default instead of failing the move.
• Company strategy template — a dedicated company-strategy template with columns vision, mission, initiatives, quarterly_okrs, kpis, in_progress, review, and achieved.

Traditional documentation rots: written once, forgotten, and out of date within months. In Way of Teams, documentation is alive — it's part of the same system that does the work, so it stays current without anyone chasing it.

Always current, always updatable

• Updated as you work — the harness updates docs when code, tickets, or architecture change, so docs reflect reality instead of a snapshot in time.
• Edit anytime — anyone on the team can update any document; changes are tracked just like code.
• Never a rewrite project — docs grow with the work instead of piling up as debt.

Everyone can always find everything

• One searchable home — all documents live in the shared workspace, searchable and browsable by everyone.
• Team docs & project docs — runbooks, architecture, decisions, guides, and references organized per project.
• F-rr-d change tracking — every doc update is recorded, so you always know what changed and when.

Agents read and use docs as context

• Docs are context — agents read your documentation to understand the project before planning or writing code.
• Docs guide the work — architecture and decision docs keep agents aligned with your conventions and trade-offs.
• Research & knowledge — the thoughts/ context engine feeds plans, research, and lessons learned back into every session.

Agents keep docs up to date

• Self-documentation skill — the harness answers "How do I...?" from your own docs and flags gaps.
• Automatic postmortems & runbooks — incident and ops knowledge is captured in the moment, not months later.
• Session export — every working session records what was solved, changed, and decided, keeping history fresh.

What can you do with documentation?

• Onboard fast — new team members read living docs instead of bugging senior devs.
• Keep agents honest — docs that reflect reality mean AI tools build what you actually want.
• Retain knowledge — when someone leaves, their runbooks, decisions, and postmortems stay.
• Scale consistency — every project follows the same doc structure, so nothing is ever lost.
• Compliance & audit — change-tracked documentation gives you a defensible record of decisions and ops.

Every use case below runs inside Way of Teams — the same "From Meeting to Done" flow above: you sign up, you talk (or write a ticket), and the AI builds it while the whole team watches the work land on the dashboard.

People who aren't coders but want to start building

You have an idea, but you've never written code — or you tried once and gave up. Way of Teams is built to get you from idea to working software anyway:

• Describe it in plain language — "I want a site where customers can book appointments." No syntax, no setup, no terminal required to get started.
• The AI asks you the right questions — The journey guides you one step at a time: what do you want, what should it be called, what does success look like. It turns your answers into tickets automatically.
• It writes the code for you — AI agents plan, implement, test, and commit your first feature while you watch it happen. You approve and steer; you don't have to type code.
• It explains what it's doing — Every step is shown in plain language on the dashboard, so you always know what's happening and why.
• You learn by watching — Because you can see the tickets, plans, and commits, you pick up how software gets built without a course or bootcamp.
• Mistakes are safe — Review the changes, ask the AI to fix something, or start over. Nothing is permanent until you approve it.

The result: non-coders ship their first project in their first session — and build a visible, reviewable trail of how it happened along the way.

Non-developer teams that bought an AI coding tool

A small company buys Claude Code (or another AI tool) for employees who are not professional developers. With Way of Teams:

• Full visibility — the office can see what every employee's AI assistant is doing, in plain language, no technical knowledge needed.
• Simple dashboards — managers track tickets, progress, and results on a dashboard instead of reading terminal output.
• Automatic standups — reports are generated automatically, so nobody has to write status updates.
• Leadership clarity — leadership understands what's going on across the company in one easy-to-read view.

Small dev teams shipping daily

• Aligned without meetings — tickets, kanban, and standups keep everyone on the same page.
• Humans steer, AI builds — agents plan, implement, and commit features while you review and direct.
• Measured automation — skills and insights show which automations actually save time.
• No more silos — everyone sees what everyone else's AI tools did, no "what did you build?" questions.
• Fast onboarding — new devs read tickets, plans, and past sessions instead of digging through git history.

Solo founders & indie hackers

• Personal board of directors — one dashboard for tickets, standups, and AI activity.
• Capture ideas instantly — auto-ticket creation records ideas the moment you have them, so nothing gets lost.
• Boring work handled — AI agents take care of plans, commits, postmortems, runbooks.
• Scales with you — when you grow, the harness scales with you — same workflow, more people.

Startups in fast-moving markets

• Speed over ceremony — tickets flow idea → plan → implementation in minutes.
• Investor-ready records — F-rr-d change tracking gives the board a trustworthy record of what shipped.
• Quality gates kept — the review queue keeps quality without slowing the pipeline.
• Weekly clarity — standups and insights tell you what your small team actually shipped each week.

Product teams embedded with AI tooling

• PMs write, AI builds — product managers write tickets; the AI harness turns them into plans and code.
• Meetings become work — meeting notes turn into tickets, kanban cards, and calendar items automatically.
• Visibility without code — skills and review queues give PMs insight into engineering work without reading code.

Consultancies & agencies

• Client work as tickets — clear review queue and sign-off flow for every engagement.
• Delivery history — F-rr-d change tracking keeps a complete history of what was delivered and when.
• Knowledge captured — postmortems and runbooks carry lessons into the next engagement.
• Time transparency — hourly or fixed-bid, the dashboard shows exactly how much AI and human time each client consumed.

Open-source maintainers

• Automated triage — auto-create tickets and let agents handle routine PR reviews.
• Docs stay current — documentation skills keep your README, guides, and AGENTS.md up to date.
• Release automation — releases and changelogs ship with every tag.

Companies adopting AI across departments

• Every department — legal, ops, sales, and marketing can each use the harness in their own way.
• One workspace — per-team projects with org-wide visibility into what AI is being used for.
• Governance-ready — admin controls, activity dashboards, and SSO keep it compliant.

Running marketing, sales, and strategy on the same engine

Beyond software tickets, the Unified Work Engine runs the rest of the company on the same boards, tools, and AI:

• Marketing — plan a quarter of content on a content calendar board (Idea → Writing → Editing → Scheduled → Published), run campaigns on a campaign tracker, and ask the AI to draft posts from a card description.
• Personal productivity — keep a private "My Boards" space invisible to teammates, capture tasks in an Inbox column, attach files to cards, and see today's due work in the Today view.
• Company strategy — keep the company strategy on a dedicated board that moves Vision → Mission → Initiatives → Quarterly OKRs → KPIs, draft OKRs from your mission with AI, and roll up initiative status by quarter.
• One set of MCP tools — the same kanban_*, attachments_*, notes_*, and AI task types serve every niche, so your agents can plan marketing content, draft OKRs, and move your personal tasks with the same skills they use for code.

Teams evaluating AI tools

• Free to compare — run the free AI Engineering Harness and WayOfMono across OpenCode, Claude Code, and Codex.
• Side-by-side results — Way of Teams shows which tools ship what, how fast, and with what quality.
• Start free — the harness is free; only pay for the Way of Teams SaaS when you want the shared workspace.

The AI Engineering Harness provides 51+ skills, 12 agents, and workflows across 17+ AI coding tools. Install once, use everywhere.

Install on macOS or Linux

# Install the ai-harness CLI
deno run -A https://raw.githubusercontent.com/Way-Of/aiharness/main/install.ts --install-cli

# Verify the CLI
ai-harness --help

# Install all tools safely (prompts before changing existing configs)
ai-harness --tool=all

# Or install one tool
ai-harness --tool=claude
ai-harness --tool=opencode

Install on Windows

# PowerShell: install Deno
irm https://deno.land/install.ps1 | iex

# Install the ai-harness CLI and verify it
irm https://raw.githubusercontent.com/Way-Of/aiharness/main/install.ps1 | iex
ai-harness --help

# Install all tools safely
ai-harness --tool=all

Per-Tool Install

ai-harness --tool=claude          # Claude Code
ai-harness --tool=opencode        # OpenCode
ai-harness --tool=pi              # Pi
ai-harness --tool=wocode          # Wo Coder
ai-harness --tool=antigravity     # Antigravity
ai-harness --tool=codex           # Codex CLI
ai-harness --tool=gemini          # Gemini CLI

Update

# Update the CLI, skills, agents, commands, and tool configs
ai-harness --update

# Verify the installation
ai-harness --report-skills
ai-harness --sync-docs --check
ai-harness --compliance

GNU Stow (Alternative)

# Clone the repository
git clone https://github.com/Way-Of/aiharness.git ~/.ai-engineering-harness
cd ~/.ai-engineering-harness

# Install for specific tool
./setup.sh claude    # Claude Code
./setup.sh all       # All tools

What Gets Installed

The harness installs skills, agents, and commands to your AI tool's config directory:

• Skills — 51+ SKILL.md files with instructions and workflows
• Agents — 12 specialist agent definitions
• Commands — Slash commands for common workflows
• Config — Tool-specific configuration files

After installation, your AI tool will have access to all skills automatically. No additional setup needed.

Repository

Source code: github.com/Way-Of/aiharness

Way of Teams keeps a live, self-updating copy of the AI Engineering Harness in the project's .wo/ directory — the working set your Wo agent uses. It stays 100% in sync with the aiharness GitHub repo (the single source of truth) without polluting your git history.

What is synced

• Skills → .wo/skills/ — the curated 53-skill allowlist (from the Skills Catalog), plus your local wayofteams and kanban skills which are never touched.
• Agents → .wo/agents/ — the 12 specialist agent definitions.
• Prompts → .wo/prompts/ — the core workflow prompts (create-plan, implement-plan, validate-plan, ticket-create, standup, fixes-bump, fixes-create, rules).

Multi-file skills are mirrored completely (e.g. tdd includes deep-modules.md, tests.md, mocking.md and more) so every skill's internal links resolve.

How it stays clean

• Write only when changed — a file is only written when its content actually differs from what's on disk, so unchanged skills never show up in your commits.
• Deletions are mirrored — skills, agents, or prompts removed from aiharness are removed locally; only the allowlisted + local-exempt set survives.
• Syncs on boot and every 6 hours — the background HarnessSync process keeps things current automatically (and can be triggered via the admin UI / mix skills.sync).

Source of truth

• aiharness GitHub repo — manifest.json + per-tool skill/agent/prompt files
• install.ts — the canonical installer that defines what each tool gets
• Way of Teams implements the same semantics for the .wo working set: allowlist + write-only-when-changed + deletion mirroring.

Core Journey Skills

GitHub Automation Skills

Research & Analysis Skills

• research-codebase — Deep-dives into codebase
• improve-codebase-architecture — Finds friction, proposes refactors
• self-documentation — Answers "How do I...?" from project docs
• knowledge — Stores and retrieves learned knowledge

Documentation Skills

• postmortem-manager — Generates incident postmortems
• runbook-manager — Creates production runbooks
• session-export — Captures working session history
• document-generation — Generates offers, invoices, reports
• write-a-prd — Turns idea into structured PRD
• prd-to-issues — Breaks PRD into vertical-slice issues

Workflow Skills

• init-harness — Initializes harness in repository
• agents-md-manager — Keeps AGENTS.md files accurate
• ticket-organization — Audits, archives, organizes tickets
• fixes-manager — Cross-project fix/release notes
• rules-manager — Manages coding rules
• usage-rules — Syncs LLM rules from Elixir deps
• validate-podman — Validates Podman/Quadlet configs
• alliner-compliance-check — Deep f-rr-d compliance validation

Build Skills

• build-tool — Universal builder
• build-tool-skill/agent/cli/config/extension/keybindings/prompts/themes/tui

Specialized Skills

• tdd — Test-driven development
• debug — Debug issues
• git-commit-helper — Well-structured commits
• help-command — Unified help system
• sales — Sales knowledge
• auto-ticket-creator — Monitors codebase, auto-creates tickets
• backlog-groomer — Ideas into structured tickets

Other Useful Commands

• /standup — Scans git + tickets → structured standup
• /debug — Reads logs, examines state, proposes fix
• /help — Shows all skills, commands, agents (searchable)

Everything persists in the thoughts/ directory. This is your project's memory.

thoughts/
├── global/                    # Cross-project concerns
├── shared/
│   ├── tickets/              # All tickets (WOTEAMS-001-*.md)
│   ├── plans/                # Implementation plans
│   └── research/             # Notes, stack traces, code flows
└── /
    ├── docs/                 # Architecture, decisions, guides
    ├── shared/               # Project-specific tickets, plans
    └── /          # Personal workspace

WayOfMono (Wo) is our high-performance AI coding agent ecosystem. It provides two tools built on a shared intelligence backend, and it's free to use — only the Way of Teams SaaS costs money.

• wocode — The primary coding agent CLI with a terminal UI
• wouser — A general-purpose agent SDK you can build your own AI products on

Quick Install

# wocode — Wo Coder
npm install -g @wayofmono/wo-coding-agent

# wouser — Wo Agent
npm install -g @wayofmono/wo-agent

Permission error? Use sudo or set a custom prefix: npm config set prefix ~/.npm-global

wocode — Primary Coding Agent

Coding agent with read, bash, edit, write tools, session management, and a terminal UI.

wocode                              # start the agent
wocode --init                       # first-time setup
echo "Fix the bug in auth.ts" | wocode --print

Model Selection

wocode --model openai/gpt-4o
wocode --model anthropic/claude-sonnet-4-20250514
wocode --list-models

Sessions

wocode --continue
wocode --resume
wocode --session
wocode --export

Built-in Tools

wouser — Agent SDK for Your Own Products

A general-purpose agent SDK for building AI-powered applications — with skill management, extensions, and LLM integration. Use it as a dependency in your own products.

import { createAgentSession, ModelRegistry, AuthStorage } from "@wayofmono/wo-agent";

const session = await createAgentSession({
  cwd: "/my/project",
  model: someModel,
  thinkingLevel: "medium",
});

await session.prompt("Analyze this data and generate a report");

session.addEventListener((event) => {
  switch (event.type) {
    case "message_start": /* ... */ break;
    case "message_end": /* ... */ break;
  }
});

Skill & Extension Management

wouser skill install investor-ready-doc-gen
wouser skill list
wouser skill discover
wouser skill update

wouser agent install npm:@wayofmono/agent-expert-coder
wouser extension install npm:@wayofmono/extension-web-search

wocode vs wouser

Configuration

Project config (.wocode/ for wocode, .wo/ for wouser)

├── manifest.json        # Registered skills, agents, extensions
├── config.json          # Tool configuration
├── models.json          # Model/provider settings
├── skills/              # Installed skills
├── extensions/          # Installed extensions
└── themes/              # Custom themes

API Keys

export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export GEMINI_API_KEY="AIza..."
export XAI_API_KEY="xai-..."

# Ollama (local, no key needed)
ollama pull qwen3.5:9b
ollama serve

NPM Packages

Use It in Your Products

wouser is built to be embedded. Install @wayofmono/wo-agent (plus wo-agent-core, wo-ai, and wo-tui as needed) as dependencies and wire agents directly into your application.

npm install @wayofmono/wo-agent @wayofmono/wo-ai @wayofmono/wo-tui

For development and support: GitHub Issues · NPM Packages.

Way of Teams works with 30+ LLM providers — local models (LM Studio, Ollama, llama.cpp) and cloud providers (xAI, OpenAI, Anthropic, DeepSeek, Google, and more). You bring your own API key; Way of Teams never proxies or stores your conversations.

Connect a Provider (AI Chat)

1. Get an API key — for xAI/Grok: sign up at console.x.ai and create a key (xai-...). For other providers, use their respective consoles.
2. Open Settings in Way of Teams and find the AI provider section.
3. Pick your provider — select xai from the list. The base URL (https://api.x.ai/v1) and default model (grok-3) auto-fill via presets. Other quick-load presets: DeepSeek, OpenAI, Anthropic, Ollama.
4. Paste your key and save. Keys are stored encrypted per developer (or per company for shared keys).
5. Start chatting — open AI Chat and pick any model the provider offers: grok-4, grok-4-fast, grok-3, …

Grok Models

Company-Level Keys (Admins)

Admins can configure provider keys once for the whole company under Admin → Settings → Company Provider Keys. Every developer who hasn't set a personal key automatically uses the company key. Keys are encrypted at rest and never shared across companies.

OPENAI_API_KEY     # OpenAI GPT models
ANTHROPIC_API_KEY  # Claude models
OPENCODE_API_KEY   # Codex CLI model
XAI_API_KEY        # xAI Grok models
ANTIGRAVITY_CLI_PATH # Antigravity CLI (superadmin)

Local Models (No Key Needed)

Prefer to keep everything on your own hardware? Point the provider at a local server:

# LM Studio
Base URL: http://localhost:1234/v1

# Ollama
Base URL: http://localhost:11434/v1
ollama pull qwen3.5:9b

cat ~/.ssh/id_ed25519.pub

ssh-keygen -t ed25519

git clone [email protected]:you/repo ~/projects/repo

gh auth login

View the complete changelog on our GitHub Releases page or in the project's CHANGELOG.md file.

Recent Releases

• Unified Work Engine — One board engine for every niche: software work, personal tasks, marketing, sales, and company strategy. Board scopes + per-developer private boards ("My Boards"), sharing with member roles, column validation on card moves, company-strategy template (Vision → OKRs → KPIs), author-scoped notes, and MCP card-attachment tools.
• v0.1.0 — Initial public release with tickets, standups, skills, AI agents, kanban, and observability

For detailed development history, see the thoughts/wayofteams/CHANGELOG.md in the f-rr-d repository.

By accessing or using Way of Teams, you agree to be bound by these Terms of Service.

1. Description of Service

Way of Teams provides a collaborative platform for engineering teams including ticket tracking, standup management, AI agent workflows, skills tracking, and observability tools.

2. Acceptable Use

You agree not to use the service for any unlawful or prohibited purpose, including but not limited to: violating intellectual property rights, transmitting harmful code, or attempting to gain unauthorized access to systems.

3. User Content

You retain ownership of content you create. By using the service, you grant us a license to host, process, and display your content as necessary to provide the service.

4. Subscriptions & Billing

Paid plans are billed per seat per month or year. Upgrades are prorated. Cancellations take effect at the end of the current billing period. No refunds for partial periods.

5. Enterprise & Self-Hosted

Enterprise customers receive self-hosted deployment in their own cloud with custom SLA and dedicated support. Terms are governed by a separate enterprise agreement.

6. Disclaimer of Warranties

The service is provided "as is" without warranties of any kind, express or implied.

7. Limitation of Liability

Way of Teams shall not be liable for any indirect, incidental, or consequential damages.

8. Changes to Terms

We may update these terms with 30 days' notice. Continued use constitutes acceptance.

9. Contact

Questions about these terms? Contact us at [email protected].

Your privacy matters. This policy explains what data we collect, how we use it, and your rights.

1. Data We Collect

• Account data: Name, email, GitHub identity (if linked)
• Usage data: Tickets created, standups posted, skills tracked, agent interactions
• Technical data: IP address, browser type, access times, error logs

2. How We Use Your Data

• To provide and improve the service
• To authenticate and authorize access
• To send notifications you've opted into
• For security and fraud prevention

3. Data Sharing

We do not sell your data. We may share data with:

• Service providers (hosting, email, analytics) under data processing agreements
• Legal authorities when required by law
• Enterprise customer's own organization admins

4. AI Engineering Harness Data

When using the AI Engineering Harness, prompts and context are sent to your configured LLM provider (local or cloud). We do not log or store LLM conversations unless you enable telemetry.

5. Your Rights

• Access, correct, or delete your personal data
• Export your data in a portable format
• Object to processing or restrict processing
• Withdraw consent where processing is based on consent

6. Data Retention

Account data retained while account is active. Deleted within 30 days of account deletion. Analytics data retained for 13 months.

7. Security

We implement appropriate technical and organizational measures including encryption at rest and in transit, access controls, and regular security reviews.

8. Contact

Privacy questions? Contact [email protected].