Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Submit
ToolsExploitsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

FeedsContactPrivacy© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
Tools/GitHubGitHub/githubsecuritylab/seclab-taskflow-agent
Static AnalysisVulnerability ScannersStatic Code Analysis (SAST)Vulnerability AnalysisCode AnalysisScripting & AutomationPenetration TestingUtilities & Frameworks
Machine Learning
Learning & Education
AI-Assisted Reversing
AI Security
GitHubgithubsecuritylab/seclab-taskflow-agent

seclab-taskflow-agent

MCP-enabled multi-agent framework for declarative YAML-driven agentic workflows, used for AI-assisted code auditing, vulnerability triage, and security research with CodeQL integration.

View Repository
2874212511 days agoReviewed by Kitploit
Share

GitHub Security Lab Taskflow Agent

The Security Lab Taskflow Agent is an MCP-enabled multi-Agent framework for declarative, YAML-driven agentic workflows.

Built on top of the OpenAI Agents SDK, it uses Pydantic for grammar validation and Jinja2 for template rendering.

Core Concepts

The Taskflow Agent leverages a GitHub Workflow-esque YAML based grammar to perform a series of tasks using a set of Agents.

Its primary value proposition is as a CLI tool that allows users to quickly define and script Agentic workflows without having to write any code.

Agents are defined through personalities, that receive a task to complete, given a set of tools.

Agents can cooperate to complete sequences of tasks through so-called taskflows.

You can find a detailed overview of the taskflow grammar here and example taskflows here.

Architecture

┌─────────────────────────────────────────────────────┐
│                   CLI (cli.py)                      │
│  Typer-based entry point: -p, -t, -l, -g, -m, --resume, --lint│
└─────────────────────┬───────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────┐
│              Runner (runner.py)                     │
│  Taskflow execution loop, model resolution,         │
│  template rendering, session checkpointing          │
└─────────────────────┬───────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────┐
│          MCP Lifecycle (mcp_lifecycle.py)           │
│  Server connection, cleanup, process management     │
└─────────────────────┬───────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────┐
│            Agent (agent.py)                         │
│  TaskAgent wrapper, hooks, OpenAI Agents SDK bridge │
└─────────────────────────────────────────────────────┘

Supporting modules:
  models.py          — Pydantic v2 grammar models (validation)
  session.py         — Task-level checkpoint / resume
  available_tools.py — YAML resource loader with caching
  template_utils.py  — Jinja2 template environment
  mcp_utils.py       — MCP client parameter resolution
  mcp_transport.py   — MCP transport implementations (stdio, streamable)
  mcp_prompt.py      — System prompt construction
  prompt_parser.py   — Legacy prompt argument parser
  capi.py            — AI API endpoint and token management
  path_utils.py      — Platform-aware data/log directories

API Types

The agent supports both the Chat Completions and Responses OpenAI APIs. The API type can be configured globally or per model in a model_config file:

seclab-taskflow-agent:
  version: "1.0"
  filetype: model_config
api_type: chat_completions        # default for all models
models:
  gpt_default: gpt-4.1
  gpt_responses: gpt-5.1
model_settings:
  gpt_responses:
    api_type: responses           # override for this model
    endpoint: https://api.githubcopilot.com
    token: CAPI_TOKEN             # env var name containing the API key

Per-model model_settings can include:

  • api_type — "chat_completions" (default) or "responses"
  • endpoint — API base URL override for this model
  • token — name of an environment variable containing the API key

Backends

The runner can drive three SDKs behind a common interface:

  • openai_agents (default) — the OpenAI Agents Python SDK. Supports multi-personality handoffs, both chat_completions and responses api_type, temperature, parallel_tool_calls, exclude_from_context, and MCP over stdio, SSE, and streamable HTTP.
  • copilot_sdk — the GitHub Copilot Python SDK. Supports streaming, reasoning_effort, MCP over stdio/SSE/HTTP, and per-tool permission gating. The SDK selects its own wire protocol per model, so the YAML api_type field is not honoured; multi-personality handoffs, temperature, and parallel_tool_calls are likewise not available. Taskflows that use unsupported fields fail at load time with a BackendCapabilityError naming the offending field.
  • anthropic_sdk — the Anthropic Python SDK, driving the native Messages API (/v1/messages). Supports streaming, tool calling via MCP, and adaptive thinking with configurable reasoning.effort (low, medium, high, max). Handoffs are not supported. Designed for use with CAPI's Anthropic endpoint; auth uses Authorization: Bearer (not x-api-key).

Selection precedence (highest to lowest):

  1. Per-task backend: in the task's own model_settings block (overrides the model-level value for that one task; see _resolve_task_model()).
  2. Per-model backend: in the model config's model_settings (allows mixed backends in a single taskflow).
  3. backend: field at the top level of the model config document (global default).
  4. SECLAB_TASKFLOW_BACKEND environment variable.
  5. openai_agents.
seclab-taskflow-agent:
  version: "1.0"
  filetype: model_config
models:
  code_analysis: claude-opus-4.7
  general_tasks: gpt-5.4-mini
model_settings:
  code_analysis:
    api_type: messages
    backend: anthropic_sdk
    reasoning:
      effort: high
  general_tasks:
    api_type: responses
    backend: openai_agents

Error Translation and Retry

Each backend adapter translates its SDK-native exceptions into the neutral hierarchy in sdk/errors.py, so the runner applies retry policy without importing any SDK. Adding a backend means translating its errors too; test_every_backend_adapter_translates_transport_failures enforces this across the registry.

Transport failures need explicit handling and are easy to miss. The vendor SDKs wrap httpx only around the call that sends the request, and with streaming that returns once the response headers arrive while the body is iterated afterwards. A connection that dies mid-body therefore surfaces as a bare httpx error, in neither the SDK's own hierarchy nor the builtins'. sdk/_transport.py enumerates the retriable ones, and each adapter maps them to BackendTransportError. The set is enumerated rather than catching httpx.TransportError wholesale, because LocalProtocolError means the request was malformed and UnsupportedProtocol is deterministic.

Retry has a single owner: the branch, in _deploy_with_transport_retry. It is the only level that resets capture state between attempts, so a tool result recorded before a failure cannot be published twice or become the task's named output, and it replays only the branch that failed rather than siblings that may already have written to external systems. Retries are bounded by TASK_RETRY_LIMIT with linear backoff from TASK_RETRY_BACKOFF.

Nothing above or below that retries the same classes. Retry loops nest, so a class caught at two levels multiplies attempts rather than adding them, and each attempt replays the whole conversation. drive_backend_stream retries only BackendRateLimitError, where no content has been emitted yet, and takes a reset_capture callback so even that path cannot leave a partial attempt's results behind.

Download Tool

Most Popular

View all →

Discover the most used tools by our community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 The ultimate OSINT toolkit: investigation graph, confidence scoring, alias families, map, timeline and reports. 49 modules, 400+ sites, no API keys required.

    668
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    496
  • 3

    ARTEX

    baarai/artex

    LLM multi-agent autonomous penetration testing platform with planner/worker agents, asset and exploration graphs, MITM traffic recording, and vulnerability retesting.

    394
  • 4

    redforge

    cybersecurity91/redforge

    Browser-side red team toolkit with 102 offline tools for recon, payload generation, credential attacks, crypto, encoding and engagement reporting.

    339
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    The system of action for AI-native cybersecurity—where intent becomes governed execution, evidence becomes operational memory, and every operation improves the next.

    258
  • 6

    antifox

    antifox-ai/antifox

    AI multi-agent autonomous penetration testing platform that runs recon, attack-surface discovery, exploitation validation and evidence-backed report delivery.

    254

Explore all tools

Browse our collection of tools

View all tools →