AG

agently-runtime

Provides tools for managing and extending the Agently agent runtime environment.

Install

mkdir -p .claude/skills/agently-runtime && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/11719" && unzip -o skill.zip -d .claude/skills/agently-runtime && rm skill.zip

Installs to .claude/skills/agently-runtime

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Use when the user wants Agently runtime extension capabilities: Action Runtime, built-in action packages, legacy tool compatibility, MCP access, Execution Environment lifecycle, FastAPIHelper or streaming API exposure, auto-function helpers, KeyWaiter, or optional agently-devtools observation, evaluation, and playground integration.
334 chars✓ has a “when” triggerlonger than Claude Code's old 250-char listing cap (fine on current versions)
Advanced

Key capabilities

  • →Develop custom agent actions using `@agent.action_func`
  • →Integrate built-in action packages like Search and Browse
  • →Manage ExecutionResource lifecycle for dependencies
  • →Expose streaming APIs using FastAPIHelper
  • →Utilize `agently-devtools` for observation, evaluation, and playground integration
  • →Configure Workspace instances for shared task information

How it works

The skill provides interfaces for custom actions, built-in packages, and resource management. It allows for exposing APIs, integrating devtools, and configuring workspaces for agent execution.

Inputs & outputs

You give it
Agent application requiring model-callable capabilities or managed execution
You get back
Agent with extended runtime capabilities, custom actions, or integrated tools

When to use agently-runtime

  • →Develop custom agent actions
  • →Integrate MCP tools
  • →Manage execution resources
  • →Expose agent streaming API

About this skill

Agently Runtime

Use this Skill after the request or workflow owner is known. Use agently-triggerflow when branching, concurrency, pause/resume, retry, or multi-stage progression must remain visible in the execution graph. Use agently-stage only for process-local lifetime and sync/async bridging.

Read by Need

  • Execution selection, nested producers, run/rework/control, final validate, artifact/review, or declared Agent capabilities: agent-execution.md.
  • Callable Actions, Search/Browse, MCP/ACP, policy, artifacts, or AgentTask evidence: actions-runtime.md.
  • Action versus ExecutionResource, managed clients/sandboxes/processes/ browsers/databases, Shell/BashExecutor, PowerShell, offline/online/host profiles, approval, and streaming process I/O: actions-execution-resource.md.
  • auto_func, KeyWaiter, FastAPIHelper, SSE, or WebSocket exposure: helpers-and-services.md.
  • RuntimeEvent, logs, traces, evaluation, playground, or DevTools: devtools.md.
  • Evidence-backed reviewer comments, Coding Agent responses and rerun comparison: devtools-review.md. Requires DevTools 0.2; check the API capability before using its writeback steps.
  • TaskContext, ContextReader, SkillLibrary, and real-world Skill packages: context-and-skills.md.

Owner Boundaries

OwnerResponsibility
ActionRuntimeModel-callable operation schema, planning/dispatch, policy, and Action results.
ExecutionResourceLifecycle of live clients, sandboxes, processes, browsers, databases, and MCP sessions.
TaskWorkspaceOne task's contained files, generated artifacts, readback, identity, and promotion.
RecordStoreDurable records, links, retrieval, RuntimeEvents, checkpoints, snapshots, leases, and durable refs.
TaskContext / ContextReaderTask information bindings and consumer-bound progressive disclosure.
SkillLibraryInstalled immutable Skill revisions and resource reads; never execution permission.
AgentExecutionOne run's replaceable producer, task-scoped bindings, context, control, terminal policies, result and streams.

Do not collapse these into a generic Workspace or runtime manager. File space is not record storage; records are not model-hot context; a Skill package is not an executor or permission grant.

Runtime Rules

  • Prefer @agent.action_func and agent.use_actions(...). The tool_* and use_tool(s) names are compatibility surfaces.
  • Treat Action ids and model-planned arguments as untrusted. Validate schema, authorization, and policy before dispatch; require recorded Action evidence for claimed side effects.
  • Keep permission profiles explicit and narrow. Do not expose shell, network, browser, install, file-write, or MCP capabilities merely because an AgentTask exists.
  • Use TaskWorkspace for contained file work and verified artifact readback; use RecordStore for durable records and recovery. Keep large bodies cold behind refs until an explicit consumer reads them.
  • A real-world Skill supplies guidance and addressable resources. Actions, MCP, ExecutionResources, script authorization, and side-effect proof remain explicit host-owned bindings.
  • Use a fresh agent.create_execution() for multi-statement setup or an unrelated new request. A completed revision is immutable; explicit producer rework advances the same execution while old result readers retain their revision. See the execution contract above.
  • In 4.1.4.8, select request, plan, long_content, or long_task through create_execution(...). Final .validate(handler) is a hard output gate; .review(..., on_fail="warn" | "block") is a soft assessment with an explicit terminal policy. Review does not silently rework; rework belongs to the producer. .artifact(...) requires verified TaskWorkspace readback.
  • Use agent.create_task(...) only when the model should own bounded planning, execution evidence, verification, and replan. create_task_loop(...) is a compatibility spelling, not the recommended surface. Stable application orchestration belongs to TriggerFlow.
  • Persist resource descriptors, never live clients or secrets. Reconstruct resources through their provider/resolver during recovery.
  • Bind RuntimeEvent persistence explicitly. Availability of a RecordStore does not turn every observation into a durable event archive.
  • Observation and transport are adapters: they must not become owners of routing, authorization, workflow lifecycle, semantic acceptance, or retry.

Fail Closed

Reject unknown Skill revisions, resource refs, Action ids, selection keys, context block keys, recovery providers, and external-resume identities. Offer models one short host-issued selection key, validate it against the offered set, then reconstruct canonical records in host code.

Do not use keyword or regex matching as the semantic owner for intent, Skill relevance, route choice, evidence usefulness, or output quality. Do not fake model-owned success with canned outputs or deterministic business mappings.

When not to use it

  • →When a parallel action/tool dispatcher is built before checking Action Runtime
  • →When hand-rolling tool schema prompts or kwargs planners
  • →When prompt-only or React Skills text is accepted as proof of side effects

Limitations

  • →Prefer `@agent.action_func` and `agent.use_actions(...)` over compatibility surfaces
  • →Built-in web packages should be used through `from agently.builtins.actions import Search, Browse`
  • →Treat `agent_task.heartbeat` as observation only, not evidence or stall hiding

How it compares

This skill offers a structured way to extend Agently runtime capabilities with custom actions, built-in tools, and managed execution resources, providing a more integrated development experience than manual tool dispatching.

Compared to similar skills

agently-runtime side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
agently-runtime (this skill)03moReviewAdvanced
crewai48moNo flagsAdvanced
autonomous-agent-patterns48moReviewIntermediate
computer-use-agents108moReviewAdvanced

Try saying

Example prompts that trigger this skill in your AI assistant.

You might also like

crewai

davila7

Expert in CrewAI - the leading role-based multi-agent framework used by 60% of Fortune 500 companies. Covers agent design with roles and goals, task definition, crew orchestration, process types (sequential, hierarchical, parallel), memory systems, and flows for complex workflows. Essential for building collaborative AI agent teams. Use when: crewai, multi-agent team, agent roles, crew of agents, role-based agents.

459

autonomous-agent-patterns

davila7

Design patterns for building autonomous coding agents. Covers tool integration, permission systems, browser automation, and human-in-the-loop workflows. Use when building AI agents, designing tool APIs, implementing permission systems, or creating autonomous coding assistants.

451

computer-use-agents

davila7

Build AI agents that interact with computers like humans do - viewing screens, moving cursors, clicking buttons, and typing text. Covers Anthropic's Computer Use, OpenAI's Operator/CUA, and open-source alternatives. Critical focus on sandboxing, security, and handling the unique challenges of vision-based control. Use when: computer use, desktop automation agent, screen control AI, vision-based agent, GUI automation.

1040

voice-ai-engine-development

sickn33

Build real-time conversational AI voice engines using async worker pipelines, streaming transcription, LLM agents, and TTS synthesis with interrupt handling and multi-provider support

427

crewai-developer

smallnest

Comprehensive CrewAI framework guide for building collaborative AI agent teams and structured workflows. Use when developing multi-agent systems with CrewAI, creating autonomous AI crews, orchestrating flows, implementing agents with roles and tools, or building production-ready AI automation. Essential for developers building intelligent agent systems, task automation, and complex AI workflows.

213

hummingbot

2025Emma

Hummingbot trading bot framework - automated trading strategies, market making, arbitrage, connectors for crypto exchanges. Use when working with algorithmic trading, crypto trading bots, or exchange integrations.

213

Search skills

Search the agent skills registry