takt
TAKT Agent Koordination Topology - Define how AI agents coordinate, where humans intervene, and what gets recorded β in YAML
Stars: 458
TAKT is a tool designed to coordinate AI coding agents by providing structured review loops, managed prompts, and guardrails to ensure the delivery of quality code. It runs AI agents through YAML-defined workflows with built-in review cycles, allowing users to define tasks, queue them, and let TAKT handle the execution process. The tool is practical for daily development, reproducible with consistent results, and supports multi-agent orchestration with different personas and review criteria. TAKT is built with a focus on architecture, security, and AI antipattern review criteria, providing a comprehensive solution for code quality assurance.
README:
π―π΅ ζ₯ζ¬θͺγγγ₯γ‘γ³γ | π¬ Discord Community
TAKT Agent Koordination Topology β Give your AI coding agents structured review loops, managed prompts, and guardrails β so they deliver quality code, not just code.
TAKT runs AI agents (Claude Code, Codex, OpenCode) through YAML-defined workflows with built-in review cycles. You talk to AI to define what you want, queue tasks, and let TAKT handle the execution β planning, implementation, multi-stage review, and fix loops β all governed by declarative piece files.
TAKT is built with TAKT itself (dogfooding).
Batteries included β Architecture, security, and AI antipattern review criteria are built in. Ship code that meets a quality bar from day one.
Practical β A tool for daily development, not demos. Talk to AI to refine requirements, queue tasks, and run them. Automatic worktree isolation, PR creation, and retry on failure.
Reproducible β Execution paths are declared in YAML, keeping results consistent. Pieces are shareable β a workflow built by one team member can be used by anyone else to run the same quality process. Every step is logged in NDJSON for full traceability from task to PR.
Multi-agent β Orchestrate multiple agents with different personas, permissions, and review criteria. Run parallel reviewers, route failures back to implementers, aggregate results with declarative rules. Prompts are managed as independent facets (persona, policy, knowledge, instruction) that compose freely across workflows (Faceted Prompting).
Choose one:
- Provider CLIs: Claude Code, Codex, or OpenCode installed
- Direct API: Anthropic / OpenAI / OpenCode API Key (no CLI required)
Optional:
-
GitHub CLI (
gh) β fortakt #N(GitHub Issue tasks)
npm install -g takt$ takt
Select piece:
β― πΌ default (current)
π Development/
π Research/
> Add user authentication with JWT
[AI clarifies requirements and organizes the task]
> /go
TAKT creates an isolated worktree, runs the piece (plan β implement β review β fix loop), and offers to create a PR when done.
Use takt to queue multiple tasks, then execute them all at once:
# Queue tasks through conversation
takt
> Refactor the auth module
> /go # queues the task
# Or queue from GitHub Issues
takt add #6
takt add #12
# Execute all pending tasks
takt run# List completed/failed task branches β merge, retry, or delete
takt listTAKT uses a music metaphor β the name itself comes from the German word for "beat" or "baton stroke," used in conducting to keep an orchestra in time. In TAKT, a piece is a workflow and a movement is a step within it, just as a musical piece is composed of movements.
A piece defines a sequence of movements. Each movement specifies a persona (who), permissions (what's allowed), and rules (what happens next). Here's a minimal example:
name: plan-implement-review
initial_movement: plan
max_movements: 10
movements:
- name: plan
persona: planner
edit: false
rules:
- condition: Planning complete
next: implement
- name: implement
persona: coder
edit: true
required_permission_mode: edit
rules:
- condition: Implementation complete
next: review
- name: review
persona: reviewer
edit: false
rules:
- condition: Approved
next: COMPLETE
- condition: Needs fix
next: implement # β fix loopRules determine the next movement. COMPLETE ends the piece successfully, ABORT ends with failure. See the Piece Guide for the full schema, parallel movements, and rule condition types.
| Piece | Use Case |
|---|---|
default-mini |
Quick fixes. Lightweight plan β implement β parallel review β fix loop. |
default-test-first-mini |
Test-first development. Write tests first, then implement to pass them. |
frontend-mini |
Frontend-focused mini configuration. |
backend-mini |
Backend-focused mini configuration. |
expert-mini |
Expert-level mini configuration. |
default |
Serious development. Multi-stage review with parallel reviewers. Used for TAKT's own development. |
See the Builtin Catalog for all pieces and personas.
| Command | Description |
|---|---|
takt |
Talk to AI, refine requirements, execute or queue tasks |
takt run |
Execute all pending tasks |
takt list |
Manage task branches (merge, retry, instruct, delete) |
takt #N |
Execute GitHub Issue as task |
takt switch |
Switch active piece |
takt eject |
Copy builtin pieces/facets for customization |
takt repertoire add |
Install a repertoire package from GitHub |
See the CLI Reference for all commands and options.
Minimal ~/.takt/config.yaml:
provider: claude # claude, codex, or opencode
model: sonnet # passed directly to provider
language: en # en or jaOr use API keys directly (no CLI installation required):
export TAKT_ANTHROPIC_API_KEY=sk-ant-... # Anthropic (Claude)
export TAKT_OPENAI_API_KEY=sk-... # OpenAI (Codex)
export TAKT_OPENCODE_API_KEY=... # OpenCodeSee the Configuration Guide for all options, provider profiles, and model resolution.
takt eject default # Copy builtin to ~/.takt/pieces/ and editCreate a Markdown file in ~/.takt/personas/:
# ~/.takt/personas/my-reviewer.md
You are a code reviewer specialized in security.Reference it in your piece: persona: my-reviewer
See the Piece Guide and Agent Guide for details.
TAKT provides takt-action for GitHub Actions:
- uses: nrslib/takt-action@main
with:
anthropic_api_key: ${{ secrets.TAKT_ANTHROPIC_API_KEY }}
github_token: ${{ secrets.GITHUB_TOKEN }}For other CI systems, use pipeline mode:
takt --pipeline --task "Fix the bug" --auto-prSee the CI/CD Guide for full setup instructions.
~/.takt/ # Global config
βββ config.yaml # Provider, model, language, etc.
βββ pieces/ # User piece definitions
βββ facets/ # User facets (personas, policies, knowledge, etc.)
βββ repertoire/ # Installed repertoire packages
.takt/ # Project-level
βββ config.yaml # Project config
βββ facets/ # Project facets
βββ tasks.yaml # Pending tasks
βββ tasks/ # Task specifications
βββ runs/ # Execution reports, logs, context
import { PieceEngine, loadPiece } from 'takt';
const config = loadPiece('default');
if (!config) throw new Error('Piece not found');
const engine = new PieceEngine(config, process.cwd(), 'My task');
engine.on('movement:complete', (movement, response) => {
console.log(`${movement.name}: ${response.status}`);
});
await engine.run();| Document | Description |
|---|---|
| CLI Reference | All commands and options |
| Configuration | Global and project settings |
| Piece Guide | Creating and customizing pieces |
| Agent Guide | Custom agent configuration |
| Builtin Catalog | All builtin pieces and personas |
| Faceted Prompting | Prompt design methodology |
| Repertoire Packages | Installing and sharing packages |
| Task Management | Task queuing, execution, isolation |
| Data Flow | Internal data flow and architecture diagrams |
| CI/CD Integration | GitHub Actions and pipeline mode |
| Provider Sandbox | Sandbox configuration for providers |
| Changelog (ζ₯ζ¬θͺ) | Version history |
| Security Policy | Vulnerability reporting |
Join the TAKT Discord for questions, discussions, and updates.
See CONTRIBUTING.md for details.
MIT β See LICENSE for details.
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for takt
Similar Open Source Tools
takt
TAKT is a tool designed to coordinate AI coding agents by providing structured review loops, managed prompts, and guardrails to ensure the delivery of quality code. It runs AI agents through YAML-defined workflows with built-in review cycles, allowing users to define tasks, queue them, and let TAKT handle the execution process. The tool is practical for daily development, reproducible with consistent results, and supports multi-agent orchestration with different personas and review criteria. TAKT is built with a focus on architecture, security, and AI antipattern review criteria, providing a comprehensive solution for code quality assurance.
iloom-cli
iloom is a tool designed to streamline AI-assisted development by focusing on maintaining alignment between human developers and AI agents. It treats context as a first-class concern, persisting AI reasoning in issue comments rather than temporary chats. The tool allows users to collaborate with AI agents in an isolated environment, switch between complex features without losing context, document AI decisions publicly, and capture key insights and lessons learned from AI sessions. iloom is not just a tool for managing git worktrees, but a control plane for maintaining alignment between users and their AI assistants.
pr-pilot
PR Pilot is an AI-powered tool designed to assist users in their daily workflow by delegating routine work to AI with confidence and predictability. It integrates seamlessly with popular development tools and allows users to interact with it through a Command-Line Interface, Python SDK, REST API, and Smart Workflows. Users can automate tasks such as generating PR titles and descriptions, summarizing and posting issues, and formatting README files. The tool aims to save time and enhance productivity by providing AI-powered solutions for common development tasks.
factorio-learning-environment
Factorio Learning Environment is an open source framework designed for developing and evaluating LLM agents in the game of Factorio. It provides two settings: Lab-play with structured tasks and Open-play for building large factories. Results show limitations in spatial reasoning and automation strategies. Agents interact with the environment through code synthesis, observation, action, and feedback. Tools are provided for game actions and state representation. Agents operate in episodes with observation, planning, and action execution. Tasks specify agent goals and are implemented in JSON files. The project structure includes directories for agents, environment, cluster, data, docs, eval, and more. A database is used for checkpointing agent steps. Benchmarks show performance metrics for different configurations.
jido
Jido is a toolkit for building autonomous, distributed agent systems in Elixir. It provides the foundation for creating smart, composable workflows that can evolve and respond to their environment. Geared towards Agent builders, it contains core state primitives, composable actions, agent data structures, real-time sensors, signal system, skills, and testing tools. Jido is designed for multi-node Elixir clusters and offers rich helpers for unit and property-based testing.
skyvern
Skyvern automates browser-based workflows using LLMs and computer vision. It provides a simple API endpoint to fully automate manual workflows, replacing brittle or unreliable automation solutions. Traditional approaches to browser automations required writing custom scripts for websites, often relying on DOM parsing and XPath-based interactions which would break whenever the website layouts changed. Instead of only relying on code-defined XPath interactions, Skyvern adds computer vision and LLMs to the mix to parse items in the viewport in real-time, create a plan for interaction and interact with them. This approach gives us a few advantages: 1. Skyvern can operate on websites itβs never seen before, as itβs able to map visual elements to actions necessary to complete a workflow, without any customized code 2. Skyvern is resistant to website layout changes, as there are no pre-determined XPaths or other selectors our system is looking for while trying to navigate 3. Skyvern leverages LLMs to reason through interactions to ensure we can cover complex situations. Examples include: 1. If you wanted to get an auto insurance quote from Geico, the answer to a common question βWere you eligible to drive at 18?β could be inferred from the driver receiving their license at age 16 2. If you were doing competitor analysis, itβs understanding that an Arnold Palmer 22 oz can at 7/11 is almost definitely the same product as a 23 oz can at Gopuff (even though the sizes are slightly different, which could be a rounding error!) Want to see examples of Skyvern in action? Jump to #real-world-examples-of- skyvern
skilld
Skilld is a tool that generates AI agent skills from NPM dependencies, allowing users to enhance their agent's knowledge with the latest best practices and avoid deprecated patterns. It provides version-aware, local-first, and optimized skills for your codebase by extracting information from existing docs, changelogs, issues, and discussions. Skilld aims to bridge the gap between agent training data and the latest conventions, offering a semantic search feature, LLM-enhanced sections, and prompt injection sanitization. It operates locally without the need for external servers, providing a curated set of skills tied to your actual package versions.
cli
Entire CLI is a tool that integrates into your git workflow to capture AI agent sessions on every push. It indexes sessions alongside commits, creating a searchable record of code changes in your repository. It helps you understand why code changed, recover instantly, keep Git history clean, onboard faster, and maintain traceability. Entire offers features like enabling in your project, working with your AI agent, rewinding to a previous checkpoint, resuming a previous session, and disabling Entire. It also explains key concepts like sessions and checkpoints, how it works, strategies, Git worktrees, and concurrent sessions. The tool provides commands for cleaning up data, enabling/disabling hooks, fixing stuck sessions, explaining sessions/commits, resetting state, and showing status/version. Entire uses configuration files for project and local settings, with options for enabling/disabling Entire, setting log levels, strategy, telemetry, and auto-summarization. It supports Gemini CLI in preview alongside Claude Code.
metis
Metis is an open-source, AI-driven tool for deep security code review, created by Arm's Product Security Team. It helps engineers detect subtle vulnerabilities, improve secure coding practices, and reduce review fatigue. Metis uses LLMs for semantic understanding and reasoning, RAG for context-aware reviews, and supports multiple languages and vector store backends. It provides a plugin-friendly and extensible architecture, named after the Greek goddess of wisdom, Metis. The tool is designed for large, complex, or legacy codebases where traditional tooling falls short.
openapi-to-skills
Convert OpenAPI specifications into Agent Skills format - structured markdown documentation that minimizes context size for AI agents. Agent Skills solves the limitations of feeding raw OpenAPI specs to agents by structuring documentation for on-demand reading, enabling agents to load only what they need. It features semantic structure, smart grouping, filtering, and customizable templates. The tool provides options for output directory, skill name, include/exclude tags, paths, deprecated operations, grouping operations, custom templates directory, force overwrite, and quiet mode. The output structure includes SKILL.md, references, resources, operations, schemas, and authentication. The tool also offers a programmatic API for integration into build pipelines or custom tooling.
OpenAlice
Open Alice is an AI trading agent that provides users with their own research desk, quant team, trading floor, and risk management, all running on their laptop 24/7. It is file-driven, reasoning-driven, and OS-native, allowing interactions with the operating system. Features include dual AI providers, crypto trading, securities trading, market analysis, cognitive state, event log, cron scheduling, evolution mode, and a web UI. The architecture includes providers, core components, extensions, tasks, and interfaces. Users can quickly start by setting up prerequisites, AI providers, crypto trading, securities trading, environment variables, and running the tool. Configuration files, project structure, and license information are also provided.
mcp
Enable AI agents to operate reliably within real workflows. This MCP is monday.com's open framework for connecting agents into your work OS - giving them secure access to structured data, tools to take action, and the context needed to make smart decisions. The repository provides a comprehensive set of tools for AI agent developers who want to integrate with monday.com, including a plug-and-play server implementation for the Model Context Protocol (MCP) and a powerful set of tools for building AI agents that interact with the monday.com API. Users can choose between a hosted MCP service for fast and reliable connection or run the MCP locally for customization and offline development. The repository also offers advanced tools like Dynamic API Tools for full access to the monday.com GraphQL API, enabling complex reports, batch operations, and deep integration with monday.com's features.
claude-task-master
Claude Task Master is a task management system designed for AI-driven development with Claude, seamlessly integrating with Cursor AI. It allows users to configure tasks through environment variables, parse PRD documents, generate structured tasks with dependencies and priorities, and manage task status. The tool supports task expansion, complexity analysis, and smart task recommendations. Users can interact with the system through CLI commands for task discovery, implementation, verification, and completion. It offers features like task breakdown, dependency management, and AI-driven task generation, providing a structured workflow for efficient development.
k8s-operator
OpenClaw Kubernetes Operator is a platform for self-hosting AI agents on Kubernetes with production-grade security, observability, and lifecycle management. It allows users to run OpenClaw AI agents on their own infrastructure, managing inboxes, calendars, smart homes, and more through various integrations. The operator encodes network isolation, secret management, persistent storage, health monitoring, optional browser automation, and config rollouts into a single custom resource 'OpenClawInstance'. It manages a stack of Kubernetes resources ensuring security, monitoring, and self-healing. Features include declarative configuration, security hardening, built-in metrics, provider-agnostic config, config modes, skill installation, auto-update, backup/restore, workspace seeding, gateway auth, Tailscale integration, self-configuration, extensibility, cloud-native features, and more.
graphiti
Graphiti is a framework for building and querying temporally-aware knowledge graphs, tailored for AI agents in dynamic environments. It continuously integrates user interactions, structured and unstructured data, and external information into a coherent, queryable graph. The framework supports incremental data updates, efficient retrieval, and precise historical queries without complete graph recomputation, making it suitable for developing interactive, context-aware AI applications.
evalchemy
Evalchemy is a unified and easy-to-use toolkit for evaluating language models, focusing on post-trained models. It integrates multiple existing benchmarks such as RepoBench, AlpacaEval, and ZeroEval. Key features include unified installation, parallel evaluation, simplified usage, and results management. Users can run various benchmarks with a consistent command-line interface and track results locally or integrate with a database for systematic tracking and leaderboard submission.
For similar tasks
takt
TAKT is a tool designed to coordinate AI coding agents by providing structured review loops, managed prompts, and guardrails to ensure the delivery of quality code. It runs AI agents through YAML-defined workflows with built-in review cycles, allowing users to define tasks, queue them, and let TAKT handle the execution process. The tool is practical for daily development, reproducible with consistent results, and supports multi-agent orchestration with different personas and review criteria. TAKT is built with a focus on architecture, security, and AI antipattern review criteria, providing a comprehensive solution for code quality assurance.
sweep
Sweep is an AI junior developer that turns bugs and feature requests into code changes. It automatically handles developer experience improvements like adding type hints and improving test coverage.
sourcegraph
Sourcegraph is a code search and navigation tool that helps developers read, write, and fix code in large, complex codebases. It provides features such as code search across all repositories and branches, code intelligence for navigation and refactoring, and the ability to fix and refactor code across multiple repositories at once.
continue
Continue is an open-source autopilot for VS Code and JetBrains that allows you to code with any LLM. With Continue, you can ask coding questions, edit code in natural language, generate files from scratch, and more. Continue is easy to use and can help you save time and improve your coding skills.
cody
Cody is a free, open-source AI coding assistant that can write and fix code, provide AI-generated autocomplete, and answer your coding questions. Cody fetches relevant code context from across your entire codebase to write better code that uses more of your codebase's APIs, impls, and idioms, with less hallucination.
awesome-code-ai
A curated list of AI coding tools, including code completion, refactoring, and assistants. This list includes both open-source and commercial tools, as well as tools that are still in development. Some of the most popular AI coding tools include GitHub Copilot, CodiumAI, Codeium, Tabnine, and Replit Ghostwriter.
commanddash
Dash AI is an open-source coding assistant for Flutter developers. It is designed to not only write code but also run and debug it, allowing it to assist beyond code completion and automate routine tasks. Dash AI is powered by Gemini, integrated with the Dart Analyzer, and specifically tailored for Flutter engineers. The vision for Dash AI is to create a single-command assistant that can automate tedious development tasks, enabling developers to focus on creativity and innovation. It aims to assist with the entire process of engineering a feature for an app, from breaking down the task into steps to generating exploratory tests and iterating on the code until the feature is complete. To achieve this vision, Dash AI is working on providing LLMs with the same access and information that human developers have, including full contextual knowledge, the latest syntax and dependencies data, and the ability to write, run, and debug code. Dash AI welcomes contributions from the community, including feature requests, issue fixes, and participation in discussions. The project is committed to building a coding assistant that empowers all Flutter developers.
mentat
Mentat is an AI tool designed to assist with coding tasks directly from the command line. It combines human creativity with computer-like processing to help users understand new codebases, add new features, and refactor existing code. Unlike other tools, Mentat coordinates edits across multiple locations and files, with the context of the project already in mind. The tool aims to enhance the coding experience by providing seamless assistance and improving edit quality.
For similar jobs
sweep
Sweep is an AI junior developer that turns bugs and feature requests into code changes. It automatically handles developer experience improvements like adding type hints and improving test coverage.
teams-ai
The Teams AI Library is a software development kit (SDK) that helps developers create bots that can interact with Teams and Microsoft 365 applications. It is built on top of the Bot Framework SDK and simplifies the process of developing bots that interact with Teams' artificial intelligence capabilities. The SDK is available for JavaScript/TypeScript, .NET, and Python.
ai-guide
This guide is dedicated to Large Language Models (LLMs) that you can run on your home computer. It assumes your PC is a lower-end, non-gaming setup.
classifai
Supercharge WordPress Content Workflows and Engagement with Artificial Intelligence. Tap into leading cloud-based services like OpenAI, Microsoft Azure AI, Google Gemini and IBM Watson to augment your WordPress-powered websites. Publish content faster while improving SEO performance and increasing audience engagement. ClassifAI integrates Artificial Intelligence and Machine Learning technologies to lighten your workload and eliminate tedious tasks, giving you more time to create original content that matters.
chatbot-ui
Chatbot UI is an open-source AI chat app that allows users to create and deploy their own AI chatbots. It is easy to use and can be customized to fit any need. Chatbot UI is perfect for businesses, developers, and anyone who wants to create a chatbot.
BricksLLM
BricksLLM is a cloud native AI gateway written in Go. Currently, it provides native support for OpenAI, Anthropic, Azure OpenAI and vLLM. BricksLLM aims to provide enterprise level infrastructure that can power any LLM production use cases. Here are some use cases for BricksLLM: * Set LLM usage limits for users on different pricing tiers * Track LLM usage on a per user and per organization basis * Block or redact requests containing PIIs * Improve LLM reliability with failovers, retries and caching * Distribute API keys with rate limits and cost limits for internal development/production use cases * Distribute API keys with rate limits and cost limits for students
uAgents
uAgents is a Python library developed by Fetch.ai that allows for the creation of autonomous AI agents. These agents can perform various tasks on a schedule or take action on various events. uAgents are easy to create and manage, and they are connected to a fast-growing network of other uAgents. They are also secure, with cryptographically secured messages and wallets.
griptape
Griptape is a modular Python framework for building AI-powered applications that securely connect to your enterprise data and APIs. It offers developers the ability to maintain control and flexibility at every step. Griptape's core components include Structures (Agents, Pipelines, and Workflows), Tasks, Tools, Memory (Conversation Memory, Task Memory, and Meta Memory), Drivers (Prompt and Embedding Drivers, Vector Store Drivers, Image Generation Drivers, Image Query Drivers, SQL Drivers, Web Scraper Drivers, and Conversation Memory Drivers), Engines (Query Engines, Extraction Engines, Summary Engines, Image Generation Engines, and Image Query Engines), and additional components (Rulesets, Loaders, Artifacts, Chunkers, and Tokenizers). Griptape enables developers to create AI-powered applications with ease and efficiency.