Przejdź do treści
Biblioteka skilli
AI i agenci · Integracja z narzędziem

kagent

/kagent

Obsługuje agentów i samodzielne piaskownice kagent: konfigurację, wywoływanie, udostępnianie i diagnozowanie agentów oraz używanie piaskownic jako tymczasowych przestrzeni do uruchamiania skryptów i testów.

Repozytorium
kagent ↗
Licencja
Apache-2.0
Ostatnia zmiana repozytorium
27.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 27.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

Co robi i kiedy

Obsługuje agentów i samodzielne piaskownice kagent: konfigurację, wywoływanie, udostępnianie i diagnozowanie agentów oraz używanie piaskownic jako tymczasowych przestrzeni do uruchamiania skryptów i testów.

Oryginalny opis (EN)

Use kagent agents and standalone sandboxes. Use when configuring, invoking, sharing, or troubleshooting kagent agents, or using available kagent sandboxes as temporary workspaces to run scripts, test code, process files, and collect artifacts for an agent's own tasks.

Jak działa

  1. Work with an agent
  2. Use a sandbox for your task
  3. Target API
  4. Guidance rules
  5. Stable design constraints
Sekcje z nagłówków SKILL.md, w oryginale · 90 linii, 851 słów
Podgląd SKILL.md
---
name: kagent
description: >
  Use kagent agents and standalone sandboxes. Use when configuring, invoking, sharing, or
  troubleshooting kagent agents, or using available kagent sandboxes as temporary workspaces
  to run scripts, test code, process files, and collect artifacts for an agent's own tasks.
---

# kagent user guide

kagent provides agent conversations through Sessions and A2A, and standalone
scratch environments through Sandboxes. Both use Substrate. Prefer the connected
deployment's tool schemas and current API over commands from earlier releases.

## Work with an agent

Use `kagent agent --help` to discover the installed agent workflow:

- `kagent agent list` and `kagent agent get NAME` discover agent definitions.
  `kagent agent template list` and `kagent agent template get NAME` inspect
  reusable AgentTemplates. These catalog commands currently require Kubernetes
  access and use the selected namespace.
- `kagent agent session create --agent NAME --request-id REQUEST_ID` creates a
  conversation. Generate and retain a request ID for retries, and keep the
  returned Session ID. Use
  `kagent agent session list` to list your conversations and
  `kagent agent session get ID` to inspect one.
- `kagent agent invoke --session ID --task "TASK"` invokes an existing
  conversation through A2A; `--stream` streams the response. Invocation does not
  create a Session automatically.
- `kagent agent session delete ID` deletes the conversation. It does not delete
  the agent definition. `kagent apply -f FILE` creates or updates an Agent or
  AgentTemplate from a manifest.

List commands accept `--page-size` and `--page-token`; get commands require one
name or ID. Session operations use the configured kagent API connection and
identity. Invocation also uses the configured gateway connection.

## Use a sandbox for your task

When a task benefits from an isolated tools environment, use available kagent
sandbox tools to execute scripts, check code, transform supplied data, or generate
artifacts. Choose an existing prepared SandboxTemplate with the needed programs.
A Sandbox can be used directly by the current agent; creating a kagent Agent or
Session is unnecessary for this workflow.

Read [Working in sandboxes](references/sandboxes.md) before using them. It covers
CLI commands, exact MCP inputs, a worked example, recovery, and agent setup.

- When a shell and configured kagent CLI are available, use `kagent sandbox` for
  execution and file transfer. It handles bytes, output polling, and exit codes
  outside the model context. Check `kagent sandbox --help` for installed support.
- Otherwise use the authenticated kagent `/mcp` connection already available to
  you. Discover its tools and, if the client supports prompts, retrieve
  `sandbox-task` for a task or `sandbox-recovery` for an interrupted sandbox.
- Reuse a sandbox associated with the current task when its environment and
  remaining lifetime fit. Keep its ID, creation request ID, and artifact paths.
- Sandboxes currently have no allowed egress destinations. Use tools and
  dependencies already in the image, and transfer inputs through the file API.
  Plan around this before choosing work that needs downloads or remote services.
- Retrieve useful results before deleting a sandbox created for the task. If it
  needs to remain available, report its ID, expiration, and remaining artifacts.
- If no suitable connection or template is available, explain what is missing
  and continue work possible with available tools. Setting up a cluster or
  changing shared templates belongs to a requested setup task.

## Target API

- `Agent` is an `api.kagent.dev/v1alpha3` CRD pairing inline or referenced template behavior with a referenced Harness. It owns readiness and revision selection.
- `Harness` is an `api.kagent.dev/v1alpha3` CRD describing a supported runtime adapter. The release-blocking adapters are kagent, Codex, and Claude.
- `AgentTemplate` is an `api.kagent.dev/v1alpha3` CRD describing prompts, models, skills, plugins, MCP tools, and template-backed subagent tools (`tools[].subAgent`).
- `Session` is a PostgreSQL-backed gRPC resource representing a conversation and its runtime lifecycle. Use the returned `context_id` for A2A interactions.
- A2A owns interaction and task history; Session APIs own lifecycle, metadata, and sharing. Checkpoint APIs own checkpoints and Session forks.
- `SandboxTemplate` is an `api.kagent.dev/v1alpha3` CRD defining a tools image and environment. Preparing a template does not create a Sandbox.
- `Sandbox` is an owner-scoped PostgreSQL resource exposed by gRPC and MCP for process/file work. Its lifetime and files are independent of Sessions.
- Substrate is the only compute backend.

## Guidance rules

1. Inspect available tool schemas for the connected deployment. When repository source is available, use `docs/architecture` and the implementation to verify behavior.
2. Verify CRDs from `go/api/v1alpha3` and generated manifests, protobuf APIs from `proto`, MCP inputs from `go/core/internal/mcp`, and CLI behavior from command help or source.
3. Describe planned behavior as planned until its implementation has landed.
4. Do not invent compatibility paths, migration procedures, fields, commands, or endpoints that are absent from the new API.
5. Use upstream A2A operations for agent interaction and history, Session/Checkpoint APIs for conversation lifecycle, and Sandbox tools for standalone commands and files.

## Stable design constraints

- One Session pins a compiled revision of one Agent, including its template tree.
- AgentTemplate references are same-namespace.
- Shared children (`subAgent.templateRef`) run inside their parent runtime. Dedicated bindings (`subAgent.agentRef`) are accepted by the API but currently rejected during compilation.
- Runtime state lives in DurableDir and must survive suspend/resume.
- Harness and SandboxTemplate own their respective runtime configuration. AgentTemplate describes behavior; do not add infrastructure fields to it.
- Actor identities and private runtime endpoints are implementation details.

For a workflow that has not landed, identify the missing capability rather than
falling back to an earlier API or inventing a roadmap link.
Pliki w paczce (2)
  • SKILL.md 6 KB
  • references/sandboxes.md 15 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · kagent-dev/kagent100Apache-2.0
glapsfun/cnative-skills100MIT

Migawka bazy z 13.11.2026 · wersja paczki 855b1a827801 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100kagent-dev
    Wspiera rozwój kagent w repozytorium projektu: CRD Harness i AgentTemplate w wersji v1alpha3, płaszczyznę sterowania Session gRPC, integrację A2A, provisioning Substrate, testy, generowanie kodu i proces PR.
  • 100agents
    Buduje aplikacje agentów na API lub SDK Agents: narzędzia, sesje, piaskownice, przekazania między agentami, zabezpieczenia i ewaluacje.
  • 100architecture-flow-docs
    Pisze stronę architektury kagent opisującą przepływ, na przykład tworzenie agenta lub wysyłanie wiadomości, z diagramem Excalidraw.
  • 100docker-sandboxes-lifecycle
    Zarządza cyklem życia Docker Sandboxes (sbx), czyli izolowanych mikromaszyn dla agentów kodujących: tworzy, uruchamia, dołącza ponownie, wypisuje, zatrzymuje i usuwa, także dla wbudowanych agentów claude i codex.
  • 100talk-selajev-docker-sandboxes-agents
    Wyjaśnia wystąpienie Oleg Selajeva o Docker Sandboxes i pomaga projektować koncepcyjne polityki izolacji agentów: granice współdzielenia plików, polityka sieci, izolacja sekretów i oczekiwania audytowe.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.