From enterprise AI pilots to production · Python 3.10+

Agents that deliver
business results

Models can understand and generate. Business systems still need typed fields, permissioned actions, workflow lifecycle, service APIs, and run evidence. Agently connects those production gaps into one verifiable engineering chain.

Install pip install -U agently

View source Install Agently-Skills

1,588 GitHub stars 4.1.3.6 Current PyPI 176 GitHub forks

What business sees Tickets, reports, console state, and audit records instead of unstructured answers.

What engineering gets Typed fields, authorized actions, event workflows, service APIs, and traceable run evidence.

How developers start Install the framework, run the minimal chain, then add Skills and DevTools for delivery.

Models Structure Streaming Execution Flow

Python Switch providers without rewriting the business chain

profiles = {
    "chat": ("OpenAICompatible", chat_settings),
    "responses": ("OpenAIResponsesCompatible", responses_settings),
    "anthropic": ("AnthropicCompatible", anthropic_settings),
}

provider, settings = profiles[os.getenv("AGENTLY_MODEL_PROTOCOL", "chat")]
Agently.set_settings("plugins.ModelRequester.activate", provider)
Agently.set_settings(provider, settings)

data = (
    Agently.create_agent("ticket-router")
    .input("The customer reported slow support response twice.")
    .output({"priority": (str, "high / medium / low", True)})
    .get_result()
    .get_data()
)

Actual example output View full code

provider OpenAICompatible
model deepseek-chat
base_url https://api.deepseek.com/v1
api_key example-key
temperature 0
# The same business chain switches model protocols through settings.

Python Patch UI fields while the result is still streaming

execution = agent.create_execution()
execution.input(
    "The customer reported slow support response twice "
    "and wants follow-up today."
)
execution.output({
    "title": (str, "ticket title", True),
    "summary": (str, "customer feedback summary", True),
    "todo": ([str], "next actions", True),
    "priority": (str, "high / medium / low", True),
})

for item in execution.get_generator(type="instant"):
    if item.event_type == "delta" and item.delta:
        ui.patch_panel(item.path, item.delta)

ticket = execution.get_data()

Actual example output View full code

stream_prethinking_delta=True
stream_tool_call_note_delta=True
stream_reply_delta=True
reply_task_completed=True
# Field deltas can patch product UI while generation is still running.

PythonOne model result feeds multiple downstream systems

execution = agent.create_task(
    task_id="support_ticket_policy_reply",
    goal="Prepare a customer-facing support reply for ticket SUP-1842.",
    success_criteria=[
        "The final Markdown reply file exists in Workspace.",
        "The reply is grounded in billing records and policy excerpts.",
        "The reply does not promise a refund before finance review.",
    ],
    options={"routes": {"model_request": {"action_loop": {"max_rounds": 5}}}},
)

async for item in execution.get_async_generator():
    print_stream_item(item)

result = await execution.async_start()

Actual example output View full code

task_status="completed"
accepted=true
output_file_exists=true
model_judge_passed=true
replan_count=0
first_verification_failed=false
# The artifact is a sendable Markdown reply that passed policy checks.

PythonFunction Calling, MCP, and sandboxed execution

# MCP HTTP calculator
agent.use_mcp(f"http://127.0.0.1:{port}/mcp")
turn = agent.input("Use MCP actions to compute (100.25 + 55.5) * 1.08.")
records = agent.get_action_result(prompt=turn.prompt)

# Python sandbox for deterministic computation
agent.action.register_python_sandbox_action(
    action_id="python_table_stats",
    desc="Execute Python code inside a sandbox.",
    expose_to_model=True,
)
agent.use_actions("python_table_stats")

Actual example output MCP code Sandbox code

add(100.25, 55.5) -> 155.75
multiply(155.75, 1.08) -> 168.21
Python sandbox -> average=20.0
Python sandbox -> max-minus-min gap=34
ActionResult -> model_digest + artifact_refs
# MCP, function calling, and sandbox actions stay inside observable execution boundaries.

PythonEvent-driven branches and parallel work

task = Agently.create_dynamic_task(
    target=(
        "Create an incident briefing for a customer-success lead. "
        "Plan no more than three model tasks."
    ),
    max_tasks=3,
    output_schema=FRONTSTAGE_BRIEF_SCHEMA,
)
plan = await task.async_plan(max_retries=3)
validation = task.validate(plan, strict_schema_version=True)
snapshot = await task.async_run(plan, graph_input=incident_context, timeout=120)

Actual example output View full code

summarize_facts
-> assess_customer_impact
validated TaskDAG
planned_task_count=3
semantic_role=customer_success_briefing
write_customer_success_briefing
frontstage_next_update=when duplicate payment verification completes
status_banner="Latency status: resolved. Duplicate payment checks: running."
# The artifact is an account-owner briefing; the flow is runtime evidence.

PythonExpose the agent to product UI

from agently.integrations.fastapi import FastAPIHelper

agent = Agently.create_agent()

async def stream_answer(request_data):
    result = agent.input(request_data["data"]).output({
        "title": (str, "Title", True),
        "body": (str, "Reply body", True),
    }).get_result()
    async for item in result.get_async_generator(type="instant"):
        if item.delta:
            yield {"path": item.path, "delta": item.delta}

app = FastAPIHelper(response_provider=stream_answer)
app.use_post("/answer")
app.use_sse("/answer/stream")

Runtime result SSE-ready service endpoints

event: patch
data: {"path": ["title"], "delta": "Ticket"}

event: done
data: {"trace_id": "run_8f2"}

Enterprise agent engineering chain

Agently is not just another agent framework. It fills the gaps that block production.

Enterprise AI projects often fail at four boundaries: unstable system data, tool calls without control, long flows without traceability, and post-launch runs without evaluation. Agently turns those risks into capabilities teams can validate layer by layer.

Structured contract

Turn language into downstream data

Output schema, result facade, instant stream, and validation make fields usable by UI, tickets, CRM, audit, and later workflow steps.

Controlled actions

Let agents act without overreach

Actions, Function Calling, MCP, and ExecutionEnvironment put tools and scripts behind explicit owners, records, and permission boundaries.

Event workflow

Run long tasks with events and branches

TriggerFlow and Dynamic Task support sequence, parallelism, conditions, waits, resume, runtime stream, and execution snapshots.

Production operations

Observe, evaluate, and iterate after launch

FastAPIHelper, RuntimeEvent, Workspace, DevTools, and update policy let teams operate AI agents as products.

Capability stack

From one request to production workflows

Start with structured results, add external tools, then service and observe the workflow. Each layer has documentation and runnable examples.

Request

Stable output

Deliver model results as typed fields and streaming patches.

Runtime

Actions

Connect functions, MCP, sandboxes, and business systems.

Workflow

TriggerFlow

Event-driven branches, parallel work, pause/resume, and runtime streams.

DAG

Dynamic Task

Validate and execute task graphs submitted by apps or generated by models.

Dev Suite

Agently-DevTools

Put observation, evaluations, playground, and logs in one local console.

Build Suite

Agently-Skills

Help coding agents decompose and generate complex AI applications.

Agently-Skills · Official tooling for coding agents

Turn one sentence into a deliverable AI application

Agently-Skills is not the framework-side Skills Executor. It is the official guidance package for Codex, Claude Code, Cursor, and other coding agents. The current public catalog has 6 installable skills aligned with the Agently 4.1.3 runtime line, so a coding agent can start from a business goal and choose the right request, runtime, orchestration, Dynamic Task, or migration path.

Open Agently-Skills Read usage guide

Current public catalog: 6 skills Aligned with Agently 4.1.3 runtime

Install app bundleLet your coding agent follow Agently's official boundaries

export AGENT=codex

for skill in \
  agently \
  agently-request \
  agently-runtime \
  agently-dynamic-task \
  agently-triggerflow
do
  npx skills add AgentEra/Agently-Skills \
    --agent "$AGENT" --skill "$skill" -y
done

# migration path
npx skills add AgentEra/Agently-Skills \
  --agent "$AGENT" --skill agently-migration -y

You tell the coding agent

"Build a support-ticket triage agent with severity, owner, next_step, and a create-ticket action."

Use `agently-request` for structured output.
Use `agently-runtime` for controlled Actions.
Generate the service entry, test inputs, and validation checklist.

You tell the coding agent

"Split daily news automation into outline, search, pick, summarize, render, and expose SSE."

Use `agently-triggerflow` for staged and parallel nodes.
Stream runtime progress to the frontend.
Deliver an editable Markdown report artifact.

You tell the coding agent

"Move a LangGraph tool-calling flow to Agently while preserving tool boundaries and run evidence."

Use `agently-migration` for layer mapping.
Move tool calls into Actions / MCP / ExecutionEnvironment.
Add DevTools observation and regression checks.

Agently-DevTools · Local observation, evaluation, and playground

Make every agent run inspectable

agently-devtools is Agently's optional companion package. In development and staging, ObservationBridge connects Runtime Observation, Scenario Evaluations, Playground, Console, and Logs in one local console. Your Agently app can still run without it.

Run tree, graph, Mermaid, and trace help teams locate workflow paths.
EvaluationBridge connects repeated scenario evaluations with real runs.
Playground validates model settings, output contracts, and prompt variants.

Read DevTools docs pip install agently-devtools

Agently DevTools Runtime Observation real console screenshot — Real Runtime Observation view with run records, scope, connection state, and search entry.

pip install -U agently agently-devtools agently-devtools start ObservationBridge(Agently).watch(Agently)

Real deliverables

Show the business artifact, not just the framework promise

These examples have working evidence: screenshots, generated reports, interfaces, or local prototypes that can be decomposed into APIs, workflows, data contracts, and runtime evidence.

Daily News Collector generated report screenshot — Daily News Collector · public project
From one topic to an editable Markdown report

For market, research, operations, and risk teams that need repeatable news collection and report generation.

TriggerFlow stages
Structured report fields
Editable artifact

Talk to Control interface screenshot — Talk to Control · public project
Operate business objects with natural language

The system reads state, plans actions, executes or refuses, and sends runtime feedback back to the UI.

Action boundary
Schema parameters
Runtime stream

AgentlyTextParser result screenshot — AgentlyTextParser · local validation
Long-text extraction with grouped fields and evidence

Contracts, reports, interviews, and knowledge assets can become exportable JSON or forms with source references.

Long document chunks
Rule-driven schema
Evidence mapping

EDA agent plugin interface screenshot — EDA Agent Final · local prototype
From expert requirements to tool execution

The model drafts a structured plan while the host system validates hard rules, chooses alternatives, and calls tool APIs.

Topology plan
Validate gate
Tool API service

Repository examples · verifiable cases

Use real runs to explain customer value

These are not one-off website demos. They come from the Agently repository examples and keep stable key outputs, so teams can inspect what was generated, who can use it, and which engineering chain Agently supplies.

Support automation

Generate a sendable duplicate-charge reply and verify policy compliance

View full code

task_status="completed"
accepted=true
output_file_exists=true
model_judge_passed=true
replan_count=0

For support and billing teams: business systems provide invoices and policy facts, the agent writes the Markdown reply, and the judge checks that it does not invent facts or promise a refund before finance review.

Incident communication

Turn incident logs and status feedback into a customer-success briefing

View full code

summarize_facts
-> assess_customer_impact
validated TaskDAG
planned_task_count=3
semantic_role=customer_success_briefing
write_customer_success_briefing
frontstage_next_update=when duplicate payment verification completes
status_banner="Latency status: resolved. Duplicate payment checks: running."

For customer success and operations: the model plans the DAG, the status system supplies facts, and the final artifact is a briefing an account owner can use.

Enterprise renewal risk

Synthesize sales, product, support, and legal signals into a recovery package

View full code

planned_task_count=6
root_task_count=3
join_task_count=1
semantic_role=recovery_package
next_actions_count=7

For strategic accounts: CRM, usage, P1 support, commercial asks, and legal blockers are analyzed in parallel, then joined into customer messaging and internal next actions.

Controlled execution

MCP and sandbox execution make model actions recordable and reviewable

MCP code Sandbox code

MCP calculator -> 168.21
Python sandbox -> average=20.0, gap=34
ActionResult -> model_digest + artifact_refs

For tool-using systems: the model chooses the call path, MCP and sandbox execution do the deterministic work, and ActionResult keeps the evidence.

Partnership, license, and careers

Clear entry points for business, engineering, and candidates

Use public docs, project evidence, and local trials to validate the technical path. For commercial license, trademark/certification statements, or careers, use the corresponding entry point.

PerfXCloud x Agently

Public practice around cloud services, model application runtime, and enterprise AI engineering.

Developer community

Discuss business-system integration, tool governance, TriggerFlow orchestration, service delivery, and DevTools observation.

Join WeChat group

License statement

Agently open-source core uses Apache 2.0. Trademark, official certification, partner, or endorsement claims are not automatically granted by the open-source license. Contact business@agently.tech for commercial authorization.

Request authorization Read statement

Join us

We keep openings for full-stack application engineers, full-stack product managers, and technical operations/business roles. Send your resume to hr@agently.tech.

Full-stack engineerProduct managerTech ops & business

Apply

Start validating

The shortest path for engineering teams

Run one structured request first, then connect actions, workflows, services, and observability. Each step has a matching doc page.

Quickstart Structured Output Actions TriggerFlow DevTools Agently-Skills Update Policy

Agents that deliverbusiness results

Agently is not just another agent framework. It fills the gaps that block production.

Turn language into downstream data

Let agents act without overreach

Run long tasks with events and branches

Observe, evaluate, and iterate after launch

From one request to production workflows

Stable output

Actions

TriggerFlow

Dynamic Task

Agently-DevTools

Agently-Skills

Turn one sentence into a deliverable AI application

Make every agent run inspectable

Show the business artifact, not just the framework promise

From one topic to an editable Markdown report

Operate business objects with natural language

Long-text extraction with grouped fields and evidence

From expert requirements to tool execution

Use real runs to explain customer value

Generate a sendable duplicate-charge reply and verify policy compliance

Turn incident logs and status feedback into a customer-success briefing

Synthesize sales, product, support, and legal signals into a recovery package

MCP and sandbox execution make model actions recordable and reviewable

Clear entry points for business, engineering, and candidates

PerfXCloud x Agently

Developer community

License statement

Join us

The shortest path for engineering teams

Agents that deliver
business results