jat
The World's First Agentic IDE. Visual dashboard: live sessions, task management, code editor, terminal. Epic Swarm parallel workflows. Auto-proceed rules. Automation patterns. Beads + Agent Mail + 50 bash tools. Supervise 20+ agents from one UI.
Stars: 144
JAT is a complete, self-contained environment for agentic development, offering task management, agent orchestration, code editor, git integration, and terminal access all in a single IDE. It allows users to connect various external sources like RSS, Slack, Telegram, and Gmail to create tasks and spawn agents automatically. JAT supports hands-on supervision of agents or autonomous operation. The tool provides features such as multi-agent management, task management, smart question UI, epic swarm for parallel agent spawning, autonomous triggers, task scheduling, error recovery, and a skill marketplace. JAT is designed to be a control tower for managing a swarm of agents, whether actively supervised or running autonomously.
README:
╔───────────────────────────────────────────╗
│ │
│ __ ___ .___________. │
│ | | / \ | | │
│ | | / ^ \ `---| |----` │
│ .--. | | / /_\ \ | | │
│ | `--' | / _____ \ | | │
│ \______/ /__/ \__\ |__| │
│ │
│ ◇ Supervise the Swarm ◇ │
│ │
╚───────────────────────────────────────────╝
Agents ship, suggest, repeat. You supervise — or they run on their own.
JAT is the complete, self-contained environment for agentic development. Task management, agent orchestration, code editor, git integration, terminal access—all unified in a single IDE. Connect RSS, Slack, Telegram, Gmail — events create tasks and spawn agents automatically. No plugins to install, no services to configure, no pieces to assemble. Supervise the swarm hands-on, or let it run autonomously while you sleep.
The JAT IDE: agent sessions, task management, and code editor unified
Traditional IDE: You write code, tools assist
Copilot IDE: You write code, AI suggests completions
Agentic IDE: Agents write code, you supervise and approve
Autonomous Platform: Events trigger agents, work ships while you sleep
JAT supports all four. Manage 20+ agents hands-on, or connect external sources and let agents spawn themselves.
# Install (one command)
curl -sSL https://raw.githubusercontent.com/joewinke/jat/master/tools/scripts/bootstrap.sh | bash
# Restart shell
source ~/.bashrc
# Launch
jatOpen http://localhost:3333 → Add a project → Create a task → Spawn an agent → Supervise
Alternative (developers):
git clone https://github.com/joewinke/jat.git ~/code/jat
cd ~/code/jat && ./install.sh| Shortcut | Feature |
|---|---|
Cmd+K |
Global Search — files, tasks, agents |
Cmd+Shift+T |
Terminal — integrated with agent sessions |
Ctrl+S |
Save — save current file |
Alt+N |
New Task — create from anywhere |
Alt+E |
Epic Swarm — launch parallel agents |
Full Monaco editor (VS Code's engine):
┌─────────────────────────────────────────────────────────────┐
│ 📁 Files │ 🔀 Git │
├─────────────────────────────────────────────────────────────┤
│ ▼ src/ │ ┌─────┬─────┬─────┐ │
│ lib/ │ │ a.ts│ b.ts│ c.ts│ ← Drag-drop tabs │
│ routes/ │ └─────┴─────┴─────┘ │
│ ▼ tests/ │ ┌──────────────────────────────────────────┐ │
│ │ │ Monaco Editor │ │
│ │ │ • 25+ languages │ │
│ │ │ • Syntax highlighting │ │
│ │ │ • Multi-cursor editing │ │
│ │ └──────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
- Lazy-loading file tree with right-click context menu
- Multi-file tabs with persistent order
- Keyboard navigation (F2 rename, Delete remove)
- File type icons
Full git integration:
┌─────────────────────────────────────────────────────────────┐
⎇ master ↑2 ↓0 [⟳ Fetch] │
├─────────────────────────────────────────────────────────────┤
│ ▼ STAGED CHANGES (3) [− All] │
│ M src/lib/api.ts │
│ A src/lib/auth.ts │
├─────────────────────────────────────────────────────────────┤
│ [ Commit message... ] [✓ Commit] │
├─────────────────────────────────────────────────────────────┤
│ ▼ CHANGES (2) [+ All] │
│ M src/routes/+page.svel te [+] [↻] │
├─────────────────────────────────────────────────────────────┤
│ [↑ Push] [↓ Pull] │
├─────────────────────────────────────────────────────────────┤
│ ▼ TIMELINE │
│ ● abc123 2h ago Add authentication │
│ ○ def456 1d ago Fix login bug │
└─────────────────────────────────────────────────────────────┘
- Stage/unstage individual files or all
- Commit with
Ctrl+Enter - Push/Pull with ahead/behind indicators
- Branch switcher with search
- Diff preview drawer (click any file)
- Commit timeline with details
Live terminal output for all running agents:
- Real-time streaming output
- Smart question UI (agent questions → clickable buttons)
- State badges: Working, Needs Input, Review, Completed
- Send input directly to agents
- Token usage and cost tracking
JAT Tasks-powered issue tracking:
- Create tasks with priorities (P0-P4)
- Epic workflows with subtask spawning
- Dependency visualization
- Bulk actions (select multiple, add to epic)
Full commit history and repository management:
- Browse all commits with details
- Multi-select commits for cherry-pick or revert
- Search commits by message or author
- Diff viewer for any commit
┌──────────────────────────────────────────────────────────────┐
│ │
│ 1. PLAN WITH AI Describe your feature, get PRD │
│ ↓ │
│ 2. /JAT:TASKTREE Convert PRD → structured tasks │
│ ↓ │
│ 3. EPIC SWARM Spawn agents on subtasks │
│ ↓ │
│ 4. PARALLEL WORK Watch agents code simultaneously │
│ ↓ │
│ 5. SMART QUESTIONS "OAuth or JWT?" → click button │
│ ↓ │
│ 6. REVIEW IN /tasks See diffs, approve changes │
│ ↓ │
│ 7. COMMIT & PUSH Stage, message, push │
│ ↓ │
│ 8. AUTO-PROCEED Low-priority tasks complete auto │
│ ↓ │
│ 9. SUGGESTED TASKS Agent proposes next work │
│ ↓ │
│ ╰──────────────── Auto-accept → back to 3 ───────────╯│
│ │
│ ∞ Perpetual motion. Ship continuously. ∞ │
│ │
└──────────────────────────────────────────────────────────────┘
JAT connects to external sources. When events arrive, tasks are created and agents spawn — no human in the loop required.
| Integration | Source | Example |
|---|---|---|
| Telegram | Chat messages | DM your bot a request, agent acts instantly |
| Slack | Channel messages | Team requests from #support spawn agents |
| RSS | Any RSS/Atom feed | Monitor blogs, CI feeds, Hacker News |
| Gmail | Email inbox | Forward client emails, agent processes them |
| Custom | Plugin system | Any API or data source (PLUGINS.md) |
| Mode | When Agent Spawns | Use Case |
|---|---|---|
| Immediate | Instantly on event | Telegram: message JAT, agent starts now |
| Delay | After N min/hours | Batch morning emails, start after lunch |
| Schedule | At a specific time | "Process feed items at 9 AM" |
| Cron | Recurring schedule | "Every weekday at 9 AM, review PRs" |
1. You message your Telegram bot: "Add dark mode to the settings page"
2. JAT ingest daemon receives the message
3. Task created: "Add dark mode to the settings page" (P1, immediate trigger)
4. Agent spawns automatically, picks up the task
5. Agent writes code, commits, opens PR
6. You wake up to a completed PR
The built-in scheduler daemon (jat scheduler start) handles cron and one-shot triggers. It polls task databases, spawns agents for due tasks, and manages recurring schedules automatically. See scheduler docs.
Build your own adapter with the plugin system. See PLUGINS.md for the adapter interface.
| Route | Purpose |
|---|---|
/tasks |
Agent sessions, task management, epics, questions, state tracking |
/files |
Monaco editor, file tree, staged/unstaged changes |
/source |
Full commit history, cherry-pick, revert, diffs |
/integrations |
External source connections (RSS, Slack, Telegram, Gmail) |
/servers |
Dev server controls, task scheduler management |
/config |
API keys, project secrets, automation rules, shortcuts |
| Feature | Description |
|---|---|
| Multi-agent management | Run 20+ agents simultaneously across your codebase |
| Task → Agent → Review | One-click workflow from task to completion |
| Smart question UI | Agent questions become clickable buttons |
| Epic Swarm | Spawn parallel agents on subtasks |
| Auto-proceed rules | Configure auto-completion by type/priority |
| External integrations | RSS, Slack, Telegram, Gmail feed events into tasks |
| Autonomous triggers | Events spawn agents automatically (immediate/delay/schedule/cron) |
| Task scheduling | Cron-based recurring tasks and one-shot scheduled spawns |
| Error recovery | Automatic retry patterns for failures |
| PRD → Tasks |
/jat:tasktree converts requirements to structured tasks |
| Skill marketplace | Install community skills, auto-synced to all agents |
Full Monaco editor and git integration included—but the magic is in agent orchestration.
| Feature | JAT | Cursor | Windsurf | Cline/Aider |
|---|---|---|---|---|
| Multi-agent (20+) | ✅ | ❌ | ❌ | ❌ |
| Visual IDE | ✅ | ❌ | ❌ | ❌ |
| Task management | ✅ Built-in | ❌ | ❌ | ❌ |
| Epic Swarm (parallel) | ✅ | ❌ | ❌ | ❌ |
| Agent coordination | ✅ Agent Registry | ❌ | ❌ | ❌ |
| External integrations | ✅ RSS, Slack, Telegram, Gmail | ❌ | ❌ | ❌ |
| Autonomous triggers | ✅ | ❌ | ❌ | ❌ |
| Auto-proceed rules | ✅ | ❌ | ❌ | ❌ |
| Code editor | ✅ Monaco | ✅ VS Code | ✅ VS Code | ❌ |
| Git integration | ✅ | ✅ | ✅ | Partial |
| Skill marketplace | ✅ Install & auto-sync | ❌ | ❌ | ❌ |
| Supabase integration | ✅ Migrations | ❌ | ❌ | ❌ |
| 100% local | ✅ | ❌ Cloud | ❌ Cloud | ✅ |
| Open source | ✅ MIT | ❌ | ❌ | ✅ |
JAT isn't trying to replace your editor — it's the control tower for your agent swarm, whether you're at the controls or asleep.
~/code/jat/
├── ide/ # SvelteKit app (the IDE)
│ └── src/
│ ├── routes/ # /tasks, /files, /source, /integrations, /servers, /config
│ └── lib/
│ ├── components/files/ # FileTree, GitPanel, Editor
│ ├── components/work/ # SessionCard, WorkPanel
│ ├── components/source/ # CommitHistory, DiffViewer
│ ├── components/ingest/ # Integration management UI
│ └── stores/ # State management
├── tools/ # 50+ CLI tools
│ ├── core/ # Database, monitoring
│ ├── mail/ # Agent coordination (am-*)
│ ├── browser/ # Browser automation
│ ├── ingest/ # Feed ingest daemon (RSS, Slack, Telegram, Gmail)
│ ├── scheduler/ # Task scheduling daemon (cron + one-shot)
│ └── signal/ # State sync
├── commands/ # /jat:start, /jat:complete, /jat:tasktree
└── shared/ # Agent documentation
- Node.js 20+
- tmux (agent sessions)
- Claude Code or similar AI assistant
- sqlite3, jq (auto-installed)
No API keys required. JAT uses your existing AI assistant subscriptions.
Most coding agents authenticate via their own subscriptions — no separate API keys needed:
| Agent | Auth Method | Setup |
|---|---|---|
| Claude Code | Claude Pro/Max subscription | claude auth |
| Codex CLI | ChatGPT Plus/Pro subscription | codex login |
| Gemini CLI | Google Account (free tier included) | First run triggers OAuth |
| Aider | API keys only | Set provider key in env |
JAT's built-in AI features (task suggestions, avatars) use an auto-fallback system:
- Anthropic API key — if configured (optional)
-
Claude CLI — falls back to your Claude subscription via
claude -p
If you have Claude Code installed and authenticated, AI features work out of the box with zero configuration.
~/.config/jat/projects.json:
{
"projects": {
"myapp": {
"path": "~/code/myapp",
"port": 3000
}
},
"defaults": {
"max_sessions": 12,
"model": "opus",
"scheduler_autostart": true,
"timezone": "America/New_York"
}
}Optional: API keys and project secrets can be managed at /config → API Keys tab, or stored in ~/.config/jat/credentials.json:
{
"apiKeys": {
"anthropic": { "key": "sk-ant-..." }
},
"customApiKeys": {
"stripe": { "value": "sk_live_...", "envVar": "STRIPE_API_KEY" }
},
"projectSecrets": {
"myapp": { "supabase_anon_key": { "value": "..." } }
}
}Access secrets in scripts:
jat-secret stripe # Get value
eval $(jat-secret --export) # Load all as env varsIDE settings at /config:
- API keys and custom secrets (optional)
- Per-project credentials (Supabase, databases)
- Agent routing rules
- Automation rules
- Keyboard shortcuts
| Doc | Purpose |
|---|---|
| QUICKSTART.md | 5-minute tutorial |
| CLAUDE.md | Full technical reference |
| ide/CLAUDE.md | IDE dev guide |
| shared/scheduler.md | Scheduler daemon reference |
| tools/ingest/PLUGINS.md | Custom integration plugin guide |
| shared/ | Agent documentation |
Which AI assistants work? Any terminal-based AI: Claude Code, Aider, Cline, Codex, etc.
How many agents can I run? Tested with 20+. Limited by your machine and API limits, not JAT.
Can I use existing projects?
Yes. Run jt init in any git repo to initialize task tracking, then add the project via /config → Projects tab, or use the "Add Project" button on the Tasks page.
Can JAT act on Slack/Telegram messages? Yes. The ingest daemon connects to Telegram bots, Slack channels, RSS feeds, and Gmail. Incoming events create tasks and spawn agents automatically — immediately, on a delay, at a scheduled time, or on a cron. See Integrations.
Can I schedule recurring tasks? Yes. Set a cron expression on any task and the scheduler daemon will spawn agents automatically. See scheduler docs.
Is there a hosted version? No. JAT runs 100% locally. Code never leaves your machine.
- Discord — Join the JAT community for help, discussion, and sharing what you've built
- Issues — Report bugs or request features
- Discussions — GitHub Discussions for questions and ideas
We welcome contributions! See CONTRIBUTING.md for guidelines.
Quick start for contributors:
git clone https://github.com/joewinke/jat.git ~/code/jat
cd ~/code/jat/ide
npm install && npm run devOpen a PR against master. All contributions are licensed under MIT.
- Joe Winke — Creator Github
- Agent Registry — Original Agent Comms inspiration (Dicklesworthstone/mcp_agent_mail)
- Beads — Original task management inspiration (steveyegge/beads)
- Mario Zechner — Think different about Agents (What if you don't need MCP?)
- Andrej Karpathy - Naming the Problem (Some Powerful Alien Tool)
- DHH - Developer-centric OS (Omarchy)
- Tmux - Terminal Multiplexer by (Nicholas Marriott)
- Monaco — Code editor engine (Microsoft)
- SvelteKit — IDE framework (Rich Harris)
- Tailwind CSS — Utility-first CSS (Adam Wathan)
- DaisyUI — Component library (Pouya Saadeghi)
- Git — Version control (Linus Torvalds)
- simple-git — Node.js Git wrapper (Steve King)
- D3.js — Data visualization (Mike Bostock)
- Vite — Build tool (Evan You)
- SQLite — Embedded database (D. Richard Hipp)
- TypeScript — Type safety (Anders Hejlsberg)
- Claude — Wrote a lot of the code (Anthropic)
MIT - This is my gift to all the great's who haved gifted so much to all of us. If you use this software, use it to make something you give back to open-source.
JAT: Supervise the swarm — or let it run autonomously.
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for jat
Similar Open Source Tools
jat
JAT is a complete, self-contained environment for agentic development, offering task management, agent orchestration, code editor, git integration, and terminal access all in a single IDE. It allows users to connect various external sources like RSS, Slack, Telegram, and Gmail to create tasks and spawn agents automatically. JAT supports hands-on supervision of agents or autonomous operation. The tool provides features such as multi-agent management, task management, smart question UI, epic swarm for parallel agent spawning, autonomous triggers, task scheduling, error recovery, and a skill marketplace. JAT is designed to be a control tower for managing a swarm of agents, whether actively supervised or running autonomously.
vibium
Vibium is a browser automation infrastructure designed for AI agents, providing a single binary that manages browser lifecycle, WebDriver BiDi protocol, and an MCP server. It offers zero configuration, AI-native capabilities, and is lightweight with no runtime dependencies. It is suitable for AI agents, test automation, and any tasks requiring browser interaction.
pilot
Pilot is an AI tool designed to streamline the process of handling tickets from GitHub, Linear, Jira, or Asana. It plans the implementation, writes the code, runs tests, and opens a PR for you to review and merge. With features like Autopilot, Epic Decomposition, Self-Review, and more, Pilot aims to automate the ticket handling process and reduce the time spent on prioritizing and completing tasks. It integrates with various platforms, offers intelligence features, and provides real-time visibility through a dashboard. Pilot is free to use, with costs associated with Claude API usage. It is designed for bug fixes, small features, refactoring, tests, docs, and dependency updates, but may not be suitable for large architectural changes or security-critical code.
aiohomematic
AIO Homematic (hahomematic) is a lightweight Python 3 library for controlling and monitoring HomeMatic and HomematicIP devices, with support for third-party devices/gateways. It automatically creates entities for device parameters, offers custom entity classes for complex behavior, and includes features like caching paramsets for faster restarts. Designed to integrate with Home Assistant, it requires specific firmware versions for HomematicIP devices. The public API is defined in modules like central, client, model, exceptions, and const, with example usage provided. Useful links include changelog, data point definitions, troubleshooting, and developer resources for architecture, data flow, model extension, and Home Assistant lifecycle.
open-computer-use
Open Computer Use is an open-source platform that enables AI agents to control computers through browser automation, terminal access, and desktop interaction. It is designed for developers to create autonomous AI workflows. The platform allows agents to browse the web, run terminal commands, control desktop applications, orchestrate multi-agents, stream execution, and is 100% open-source and self-hostable. It provides capabilities similar to Anthropic's Claude Computer Use but is fully open-source and extensible.
vllm-mlx
vLLM-MLX is a tool that brings native Apple Silicon GPU acceleration to vLLM by integrating Apple's ML framework with unified memory and Metal kernels. It offers optimized LLM inference with KV cache and quantization, vision-language models for multimodal inference, speech-to-text and text-to-speech with native voices, text embeddings for semantic search and RAG, and more. Users can benefit from features like multimodal support for text, image, video, and audio, native GPU acceleration on Apple Silicon, compatibility with OpenAI API, Anthropic Messages API, reasoning models extraction, integration with external tools via Model Context Protocol, memory-efficient caching, and high throughput for multiple concurrent users.
Shannon
Shannon is a battle-tested infrastructure for AI agents that solves problems at scale, such as runaway costs, non-deterministic failures, and security concerns. It offers features like intelligent caching, deterministic replay of workflows, time-travel debugging, WASI sandboxing, and hot-swapping between LLM providers. Shannon allows users to ship faster with zero configuration multi-agent setup, multiple AI patterns, time-travel debugging, and hot configuration changes. It is production-ready with features like WASI sandbox, token budget control, policy engine (OPA), and multi-tenancy. Shannon helps scale without breaking by reducing costs, being provider agnostic, observable by default, and designed for horizontal scaling with Temporal workflow orchestration.
mesh
MCP Mesh is an open-source control plane for MCP traffic that provides a unified layer for authentication, routing, and observability. It replaces multiple integrations with a single production endpoint, simplifying configuration management. Built for multi-tenant organizations, it offers workspace/project scoping for policies, credentials, and logs. With core capabilities like MeshContext, AccessControl, and OpenTelemetry, it ensures fine-grained RBAC, full tracing, and metrics for tools and workflows. Users can define tools with input/output validation, access control checks, audit logging, and OpenTelemetry traces. The project structure includes apps for full-stack MCP Mesh, encryption, observability, and more, with deployment options ranging from Docker to Kubernetes. The tech stack includes Bun/Node runtime, TypeScript, Hono API, React, Kysely ORM, and Better Auth for OAuth and API keys.
memsearch
Memsearch is a tool that allows users to give their AI agents persistent memory in a few lines of code. It enables users to write memories as markdown and search them semantically. Inspired by OpenClaw's markdown-first memory architecture, Memsearch is pluggable into any agent framework. The tool offers features like smart deduplication, live sync, and a ready-made Claude Code plugin for building agent memory.
osmedeus
Osmedeus is a security-focused declarative orchestration engine that simplifies complex workflow automation into auditable YAML definitions. It provides powerful automation capabilities without compromising infrastructure integrity and safety. With features like declarative YAML workflows, multiple runners, event-driven triggers, template engine, utility functions, REST API server, distributed execution, notifications, cloud storage, AI integration, SAST integration, language detection, and preset installations, Osmedeus offers a comprehensive solution for security automation tasks.
myclaw
myclaw is a personal AI assistant built on agentsdk-go that offers a CLI agent for single message or interactive REPL mode, full orchestration with channels, cron, and heartbeat, support for various messaging channels like Telegram, Feishu, WeCom, WhatsApp, and a web UI, multi-provider support for Anthropic and OpenAI models, image recognition and document processing, scheduled tasks with JSON persistence, long-term and daily memory storage, custom skill loading, and more. It provides a comprehensive solution for interacting with AI models and managing tasks efficiently.
room
Quoroom is an open research project focused on autonomous agent collectives. It allows users to run a swarm of AI agents that pursue goals autonomously, with a Queen strategizing, Workers executing tasks, and Quorum voting on decisions. The tool enables agents to learn new skills, modify their behavior, manage a crypto wallet, and rent cloud stations for additional compute power. The architecture is inspired by swarm intelligence research, emphasizing decentralized decision-making and emergent behavior from local interactions.
NeuroSploit
NeuroSploit v3 is an advanced security assessment platform that combines AI-driven autonomous agents with 100 vulnerability types, per-scan isolated Kali Linux containers, false-positive hardening, exploit chaining, and a modern React web interface with real-time monitoring. It offers features like 100 Vulnerability Types, Autonomous Agent with 3-stream parallel pentest, Per-Scan Kali Containers, Anti-Hallucination Pipeline, Exploit Chain Engine, WAF Detection & Bypass, Smart Strategy Adaptation, Multi-Provider LLM, Real-Time Dashboard, and Sandbox Dashboard. The tool is designed for authorized security testing purposes only, ensuring compliance with laws and regulations.
giztoy
Giztoy is a multi-language framework designed for building AI toys and intelligent applications. It provides a unified abstraction layer that spans from resource-constrained embedded systems to powerful cloud services. With features like native support for ESP32 and other MCUs, cross-platform app development, a unified build system with Bazel, an agent framework for AI agents, audio processing capabilities, support for various Large Language Models, real-time models with WebSocket streaming, secure transport protocols, and multi-language implementations in Go, Rust, Zig, and C/C++, Giztoy serves as a versatile tool for developing AI-powered applications across different platforms and devices.
tinyclaw
TinyClaw is a lightweight wrapper around Claude Code that connects WhatsApp via QR code, processes messages sequentially, maintains conversation context, runs 24/7 in tmux, and is ready for multi-channel support. Its key innovation is the file-based queue system that prevents race conditions and enables multi-channel support. TinyClaw consists of components like whatsapp-client.js for WhatsApp I/O, queue-processor.js for message processing, heartbeat-cron.sh for health checks, and tinyclaw.sh as the main orchestrator with a CLI interface. It ensures no race conditions, is multi-channel ready, provides clean responses using claude -c -p, and supports persistent sessions. Security measures include local storage of WhatsApp session and queue files, channel-specific authentication, and running Claude with user permissions.
boxlite
BoxLite is an embedded, lightweight micro-VM runtime designed for AI agents running OCI containers with hardware-level isolation. It is built for high concurrency with no daemon required, offering features like lightweight VMs, high concurrency, hardware isolation, embeddability, and OCI compatibility. Users can spin up 'Boxes' to run containers for AI agent sandboxes and multi-tenant code execution scenarios where Docker alone is insufficient and full VM infrastructure is too heavy. BoxLite supports Python, Node.js, and Rust with quick start guides for each, along with features like CPU/memory limits, storage options, networking capabilities, security layers, and image registry configuration. The tool provides SDKs for Python and Node.js, with Go support coming soon. It offers detailed documentation, examples, and architecture insights for users to understand how BoxLite works under the hood.
For similar tasks
scaleapi-python-client
The Scale AI Python SDK is a tool that provides a Python interface for interacting with the Scale API. It allows users to easily create tasks, manage projects, upload files, and work with evaluation tasks, training tasks, and Studio assignments. The SDK handles error handling and provides detailed documentation for each method. Users can also manage teammates, project groups, and batches within the Scale Studio environment. The SDK supports various functionalities such as creating tasks, retrieving tasks, canceling tasks, auditing tasks, updating task attributes, managing files, managing team members, and working with evaluation and training tasks.
atlas-mcp-server
ATLAS (Adaptive Task & Logic Automation System) is a high-performance Model Context Protocol server designed for LLMs to manage complex task hierarchies. Built with TypeScript, it features ACID-compliant storage, efficient task tracking, and intelligent template management. ATLAS provides LLM Agents task management through a clean, flexible tool interface. The server implements the Model Context Protocol (MCP) for standardized communication between LLMs and external systems, offering hierarchical task organization, task state management, smart templates, enterprise features, and performance optimization.
Backlog.md
Backlog.md is a Markdown-native Task Manager & Kanban visualizer for any Git repository. It turns any folder with a Git repo into a self-contained project board powered by plain Markdown files and a zero-config CLI. Features include managing tasks as plain .md files, private & offline usage, instant terminal Kanban visualization, board export, modern web interface, AI-ready CLI, rich query commands, cross-platform support, and MIT-licensed open-source. Users can create tasks, view board, assign tasks to AI, manage documentation, make decisions, and configure settings easily.
jat
JAT is a complete, self-contained environment for agentic development, offering task management, agent orchestration, code editor, git integration, and terminal access all in a single IDE. It allows users to connect various external sources like RSS, Slack, Telegram, and Gmail to create tasks and spawn agents automatically. JAT supports hands-on supervision of agents or autonomous operation. The tool provides features such as multi-agent management, task management, smart question UI, epic swarm for parallel agent spawning, autonomous triggers, task scheduling, error recovery, and a skill marketplace. JAT is designed to be a control tower for managing a swarm of agents, whether actively supervised or running autonomously.
ragna
Ragna is a RAG orchestration framework designed for managing workflows and orchestrating tasks. It provides a comprehensive set of features for users to streamline their processes and automate repetitive tasks. With Ragna, users can easily create, schedule, and monitor workflows, making it an ideal tool for teams and individuals looking to improve their productivity and efficiency. The framework offers extensive documentation, community support, and a user-friendly interface, making it accessible to users of all skill levels. Whether you are a developer, data scientist, or project manager, Ragna can help you simplify your workflow management and boost your overall performance.
tegon
Tegon is an open-source AI-First issue tracking tool designed for engineering teams. It aims to simplify task management by leveraging AI and integrations to automate task creation, prioritize tasks, and enhance bug resolution. Tegon offers features like issues tracking, automatic title generation, AI-generated labels and assignees, custom views, and upcoming features like sprints and task prioritization. It integrates with GitHub, Slack, and Sentry to streamline issue tracking processes. Tegon also plans to introduce AI Agents like PR Agent and Bug Agent to enhance product management and bug resolution. Contributions are welcome, and the product is licensed under the MIT License.
Advanced-GPTs
Nerority's Advanced GPT Suite is a collection of 33 GPTs that can be controlled with natural language prompts. The suite includes tools for various tasks such as strategic consulting, business analysis, career profile building, content creation, educational purposes, image-based tasks, knowledge engineering, marketing, persona creation, programming, prompt engineering, role-playing, simulations, and task management. Users can access links, usage instructions, and guides for each GPT on their respective pages. The suite is designed for public demonstration and usage, offering features like meta-sequence optimization, AI priming, prompt classification, and optimization. It also provides tools for generating articles, analyzing contracts, visualizing data, distilling knowledge, creating educational content, exploring topics, generating marketing copy, simulating scenarios, managing tasks, and more.
aioclock
An asyncio-based scheduling framework designed for execution of periodic tasks with integrated support for dependency injection, enabling efficient and flexible task management. Aioclock is 100% async, light, fast, and resource-friendly. It offers features like task scheduling, grouping, trigger definition, easy syntax, Pydantic v2 validation, and upcoming support for running the task dispatcher on a different process and backend support for horizontal scaling.
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.