Dynamiq Agent Orchestration
Build Python workflows that coordinate LLMs, tools, agents, and RAG pipelines.
- Source repo
- dynamiq-ai/dynamiq
- Stars
- ★ 1.1k
- Last updated
- 2d ago
- License
- Apache-2.0
- Primary language
- Python
- FA score
- 61/100 · Some gaps
At a glance
- How it runs
- Works with
- Portable with changesOpenAI API
- Cost
- Free software; you pay for model usage
- Setup effort
- Low · running in minutes
- You'll need
- Typical use
- A Python engineering team needs to arrange several LLM processing stages as parallel or dependency-driven sequential workflows.
- Not a fit if
- Teams that need a ready-made app boundary without building their own
- Teams that want to avoid OpenAI, Pinecone, and other external service dependencies
- Teams that need persistent memory or production deployment configuration
- Source review
- 61/100 · Some gaps 1 safety controls not found
What does this agent do, and when should you use it?
Dynamiq is a Python orchestration framework for generative-AI applications, with an emphasis on LLM agents and retrieval-augmented generation. It builds execution graphs from Workflow, Flow, and nodes, using dependencies and InputTransformer mappings to arrange parallel or sequential work. The repository demonstrates Agent, an OpenAI LLM node, tool execution, conversational Memory, graph orchestration, and nodes for document conversion, splitting, embedding, retrieval, and storage. Workflows accept inputs such as Python dictionaries, file streams, and queries, then expose structured per-node results and generated content. Dynamiq runs as an application library; the surrounding network service, user interface, and production deployment architecture remain the adopter's responsibility.
Developers assemble directed workflows with Workflow and Flow, then connect data and execution order through .inputs(), .depends_on(), NodeDependency, and InputTransformer. An Agent combines an OpenAI LLM node with a role, loop limit, and tools; it can run synchronously or asynchronously, and a manager agent can invoke other agents as tools with parallel tool calls enabled. The indexing example reads PDF streams through PyPDFConverter, splits documents with DocumentSplitter, creates vectors with OpenAIDocumentEmbedder, and writes them using PineconeDocumentWriter. The retrieval example embeds a query with OpenAITextEmbedder, fetches documents through PineconeDocumentRetriever, and passes them into a prompted OpenAI node to produce an answer. Memory with the InMemory backend supplies conversation history, while GraphOrchestrator, GraphAgentManager, states, edges, and conditional routing support iterative feedback loops. Additional examples connect agents to E2BInterpreterTool for code execution and ScaleSerpTool for search.
- A Python engineering team needs to arrange several LLM processing stages as parallel or dependency-driven sequential workflows.
- An agent-platform developer wants a manager agent to delegate research and writing to specialist sub-agents and assemble their output.
- A knowledge-application team needs to convert PDFs, split and embed their contents, store vectors in Pinecone, and answer questions from retrieved passages.
- A prototyping team wants a command-line chatbot that tracks history using user and session identifiers.
- A workflow developer needs state transitions and conditional routing for a human-feedback content revision loop.
- A coding-assistant builder wants a ReAct-style agent to use an E2B code interpreter for computational tasks.
How do you install or deploy this agent?
Python 3.10 or later is required. Install the published package with:
pip install dynamiqAlternatively, clone the repository and synchronize its dependencies with uv:
git clone https://github.com/dynamiq-ai/dynamiq.git
cd dynamiq
uv syncThe first documented LLM invocation requires an OpenAI API key. Pinecone, E2B, and ScaleSerp credentials are additionally required only when using their respective examples and integrations.
How do you use this agent?
The following is the smallest documented LLM invocation. Replace OPENAI_API_KEY with a valid credential and run the file with Python; the generated result is available as result.output.
from dynamiq.nodes.llms.openai import OpenAI
from dynamiq.connections import OpenAI as OpenAIConnection
from dynamiq.prompts import Prompt, Message
prompt_template = """
Translate the following text into English: {{ text }}
"""
prompt = Prompt(messages=[Message(content=prompt_template, role="user")])
llm = OpenAI(
id="openai",
connection=OpenAIConnection(api_key="OPENAI_API_KEY"),
model="gpt-4o",
temperature=0.3,
max_tokens=1000,
prompt=prompt
)
result = llm.run(
input_data={
"text": "Hola Mundo!"
}
)
print(result.output)For multi-node orchestration, create a Workflow, add agents or processing nodes with wf.flow.add_nodes(...), and call wf.run(input_data={...}). Asynchronous agents use await agent.run(...). The RAG examples additionally require a Pinecone connection, an existing index name, and a matching vector dimension.
What are this agent's strengths and limitations?
- One node-and-workflow model covers direct LLM calls, sequential and parallel agents, multi-agent delegation, RAG, and state-based graph orchestration.
depends_on,.inputs(),NodeDependency, andInputTransformermake execution dependencies and inter-node data mappings explicit.- The RAG examples show an end-to-end path from PDF conversion and embedding through Pinecone storage, retrieval, and answer generation.
- Agents expose concrete controls for tools, maximum loops, behavior at the loop limit, asynchronous execution, and parallel tool calls.
- Every documented LLM and embedding example uses OpenAI, and the supplied material does not show a copyable configuration for another model provider.
- The code-execution, search, and vector-storage examples depend on E2B, ScaleSerp, and Pinecone respectively, adding external services and credentials.
- The memory example uses an
InMemorybackend; no persistent, distributed, or restart-safe memory setup is demonstrated. - No container, hosted service, HTTP API, authentication, monitoring, or production deployment configuration is provided, so adopters must build that application boundary.
How does this agent compare with similar options?
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Dynamiq Agent Orchestration This agent | 61 · Some gaps | Library / SDKFree + model costs | ★ 1.1k | 2d ago | Python | OpenAI API |
| Pocket Flow | 41 · Major gaps | Library / SDKFree + model costs | ★ 11k | 2mo ago | Python | — |
| Generative AI with LangChain | 52 · Major gaps | Library / SDKFree + model costs | ★ 1.4k | 2mo ago | Jupyter Notebook | OpenAI API · Claude API |
| Oracle AI Developer Hub | 44 · Major gaps | Library / SDKFree + model costs | ★ 4.4k | 1d ago | Jupyter Notebook | — |
How does FollowAgents rate this agent?
Why each dimension lost points
The files show explicit tool lists, loop limits, workflow dependencies, credential injection restricted to internal PRs or controlled labeled jobs, and a confidential vulnerability-reporting channel. This adequately supports ordinary data-flow, secret-handling, and dependency-governance expectations. Deductions apply because there is no framework-wide least-privilege or per-action authorization model, confirmation appears only in an illustrative email interaction, external calls and transmitted data lack a general disclosure or approval safeguard, and no rollback or compensating-action mechanism is documented. Repository metadata, documentation, licensing, and the corporate copyright notice provide attribution, but publisher identity is not independently verified, so attribution is not full-score. No red-line evidence is present.
The README, package metadata, CI, and test fixtures broadly agree on the Python framework, LLM, agent, RAG, and integration capabilities. Dependencies are usually range-bounded, Python 3.10–3.13 is declared, and containerized CI includes isolated and credentialed integration paths. Deductions reflect the exceptionally broad default dependency set and reliance on many external services, plus example inconsistencies such as the missing asyncio import and an email flow that reports sending without implementing delivery. Apart from maximum-loop behavior, failure categories, diagnostic messages, and recovery guidance are largely absent.
The evidence thoroughly covers translation, asynchronous ReAct, parallel and sequential agents, multi-agent delegation, RAG, conversational memory, and graph orchestration. Explicit tools, roles, dependencies, transformers, routers, inference modes, and loop limits provide useful capability and trigger controls. Deductions apply because there is no unified permission or capability-boundary model, LLM-directed delegation still depends on prompt conventions, and prerequisites for external credentials, system PDF/graphical libraries, resources, and deployment variants are incomplete.
The README has clear installation, documentation, examples, contribution, and licensing sections; package name, CLI, version 0.60.1, Python range, and project links are supported by metadata. The extensive readable examples justify full credit for examples despite the absence of a FAQ, and the complete Apache-2.0 text matches the declared license, justifying full license credit. Deductions apply because known limitations are only incidental, the release-page link is not a repository changelog, and maintenance is represented by team and security addresses rather than named responsibility; publisher identity also remains unverified.
Examples demonstrate consumable node output, agent content, node-keyed workflow results, and RAG indexing and retrieval paths. DAG composition, parallel execution, delegation, memory, and multiple backends provide substantial marginal value over a single LLM call. Deductions apply because output contracts, error results, and persistent side effects are not documented systematically. Although models, token limits, and loop limits are configurable, there is little guidance on monetary cost, latency, dependency weight, resource usage, or when the framework's overhead is unjustified.
Core identity, version, Python support, license, CI paths, and principal scenarios can be traced across the README, pyproject, workflows, and test fixtures, providing adequate static corroboration. Deductions apply because no execution evidence or independent validation is supplied, and the test excerpt consists mainly of shared fixtures rather than concrete behavioral assertions. Promotional or broad claims such as “all-in-one” and automatic parallelism are not clearly separated from demonstrated facts and inference; the email example can also imply a real send where only status text is printed.
- Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
- This is a static review of only the supplied revision files; no code, tests, or network integrations were executed.
- Agents can reach E2B, search providers, databases, vector stores, and cloud models. Deployers should add tool allowlists, least-privilege credentials, outbound-data disclosure, and confirmation for consequential actions.
- The README passes API-key placeholders directly while CI creates .env files containing real secrets. Verify log redaction, file cleanup, key rotation, and third-party retention policies.
- The default dependency surface is very large and includes many fast-moving service clients. Produce a lock inventory and SBOM, scan it for vulnerabilities, and consider feature-based optional dependency groups before adoption.
- The graph-orchestration email example does not send an email; it only prints a sent status. Do not treat it as evidence of external delivery, confirmation enforcement, or effect verification.
- No general rollback or compensation facility is shown. Add application-level idempotency, auditing, and recovery for workflows that write to vector stores, databases, or other stateful systems.
Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
Release notes excerpt
What's Changed * feat(mcp): list an MCP server's tools per run with that run's headers by @mykhailobuleshnyi in https://github.com/dynamiq-ai/dynamiq/pull/1013 * build: dynamiq v0.68.1 by @tyaroshko in https://github.com/dynamiq-ai/dynamiq/pull/1014 Full Changelog: https://github.com/dynamiq-ai/dynamiq/compare/v0.68.0...v0.68.1View on GitHub ↗ -
Release notes excerpt
What's Changed * fix(llms): recover from unsupported-param errors on streamed calls by @tyaroshko in https://github.com/dynamiq-ai/dynamiq/pull/989 * fix(llms): drop temperature for Claude Haiku 5.5 and recover from deprecated-param errors by @tyaroshko in https://github.com/dynamiq-ai/dynamiq/pull/990 * fix(llms): close Anthropic sync streams to prevent a connection pool deadlock by @vitalii-dynamiq in https://github.com/dynamiq-ai/dynamiq/pull/993 …View on GitHub ↗ -
Release notes excerpt
What's Changed * fix(cli): document that requirement-update replaces the optional flag by @delamainer in https://github.com/dynamiq-ai/dynamiq/pull/965 * fix(llms): send reasoning_effort "none" for models that default to it by @vitalii-dynamiq in https://github.com/dynamiq-ai/dynamiq/pull/972 * feat(storages): add Turbopuffer vector store, writer and retriever by @delamainer in https://github.com/dynamiq-ai/dynamiq/pull/976 * fix(agents): stop Anthropic content filter from silently looping agents by @tyaroshko in https://github.com/dynamiq-ai/dynamiq/pull/973 …View on GitHub ↗
FAQ
Which credentials are needed for the basic example?
Can it execute agents in parallel?
Workflow can run independent nodes in parallel where possible, and the manager-agent example enables parallel tool calls with parallel_tool_calls_enabled=True.Does it cover a complete RAG flow?
Is conversation memory persistent by default?
Memory with InMemory; it does not establish persistence across process restarts.