DMOps.ai

Appearance

DMOps.ai — Changelog ​

All notable improvements to DMOps.ai are documented here. Updates are listed newest first.

July 9, 2026 ​

✨ Agents Can Now Ask You Questions Mid-Task ​

Agents are no longer silent. When an agent needs clarification, more context, or a decision before continuing, it can now post a question directly on the task and wait for your reply.

  • Comments on every task — agents and humans can leave notes, questions, and replies directly on any task card, visible on both the web app and mobile.
  • Auto-block on question — when an agent posts a question, the task automatically moves to Blocked and an inbox notification is sent so you never miss it.
  • Auto-resume on reply — reply to the agent's question and the task automatically returns to Ready. The agent picks up with your answer as context.
  • Agent tools — agents can call task_ask_human to block and wait, task_note to log a decision or observation, and task_get_comments to read the full thread.
  • Comment badges — a 💬 count badge on task cards and the task list shows at a glance how many unread comments a task has.

July 7, 2026 ​

✨ Deterministic HTML Report Rendering ​

Agents now produce locked, reproducible HTML reports via a structured schema instead of writing raw HTML. Reports look consistent every time and are always viewable in the artifact viewer.

  • Schema-driven — agents call render_report with a ReportSchema JSON payload; the platform renders the final HTML. No inline scripts or unpredictable markup.
  • First-class artifacts — rendered reports appear as artifacts with full download, inbox handoff, and artifact viewer support.
  • Consistent styling — all reports use the platform's design system regardless of which agent produced them.

🔧 Artifact & Activity Tab — Significantly Faster Load ​

The task detail Artifacts and Activity tabs now load noticeably faster. Payload blob fetches are deferred until you open a specific artifact — the initial tab load no longer waits for large file contents.

July 6, 2026 ​

✨ Agentic Apps — Deploy Pre-Packaged AI Agent Teams ​

Install complete AI agent teams from .dmopsapp packages — no configuration from scratch.

  • One-click install — upload a .dmopsapp file or point to a GitHub URL; the platform validates and deploys all resources (agents, skills, datasets, integrations, scheduled tasks) in one step.
  • Pre-deployment validation — 10 automated checks before anything is created: ACP version compatibility, name collisions, integration requirements, and skill availability.
  • Grant management — apps declare which integrations they need, but grants are never auto-approved. Your admin reviews and approves each grant before agents can access external systems.
  • Resource attribution — every agent, skill, and dataset created by an app is tagged to it. Uninstall the app and its resources go with it.
  • App authoring UI — new Apps panel in the admin interface, with resource counts, pending grant warnings, and a 5-tab detail view (Overview, Resources, Grants, Manifest, Danger Zone).
  • Export — export any deployed app as a .dmopsapp package to redeploy or share.

✨ Voice Dictation — Speak Your Task Descriptions ​

Create tasks by speaking instead of typing, on both desktop and mobile.

  • Desktop — a 🎤 mic button in the description field corner of the New Task form.
  • Mobile — mic button lives in the modal header so it stays visible above the on-screen keyboard on Android and iOS.
  • One tap to start, one tap to stop. Transcript appends to any existing text in the field.
  • Automatically hidden in unsupported browsers (Firefox). No account or setup required — uses the browser's built-in speech recognition.

✨ Org Chart Relationship Sidebar ​

A collapsible sidebar on the org chart canvas makes delegation structure and utility agents visible at a glance.

  • Utility Agents — lists every agent tagged utility (knowledge managers, report publishers, shared services) that any delegating agent can reach, regardless of org chart position.
  • Delegation Scope — click any role on the canvas to see which agents it can delegate to. Descendant roles are highlighted in green on the canvas; utility agents are shown below the list.
  • Canvas highlighting — the selected role gets a purple accent border; all delegatable descendants get a green border. No hierarchy tracing needed.

🔧 New Task Form — Draft Auto-Save ​

The New Task form now saves your draft automatically as you type. Close the form, navigate away, or refresh the page — your draft is restored when you reopen it.

  • A "● Draft saved" badge confirms the save is current.
  • Discard draft clears it when you want a clean slate.
  • Draft is cleared automatically on successful task creation and never applied when duplicating an existing task.

✨ Email Integration — Send and Receive from Any Mailbox ​

Agents can now send and receive email through any SMTP/POP3 mailbox — AWS SES, Gmail, Outlook, or your own mail server.

  • One integration per mailbox — configure separate integrations for CEO, accounting, PMO, or support inboxes. Each is independently granted to the agents that need it.
  • Full send/receive — agents can send plain or HTML email (with CC, BCC, Reply-To), list and read incoming messages, and delete emails when done.
  • Works everywhere — compatible with AWS SES relay, Gmail SMTP, Microsoft 365, and any on-premises SMTP server. No vendor lock-in.
  • Email skill included — a dedicated email skill with subject formatting conventions, security rules, and workflow patterns is automatically available when a task requires email.

🔧 Utility Agents Automatically Available for Delegation ​

Shared-service agents (knowledge managers, report publishers, cross-cutting utilities) tagged as utility are now automatically visible to every agent for delegation — regardless of org chart position. The utility tag is auto-seeded on every startup. Admin workflow: open any agent → Tags → select utility.

July 5, 2026 ​

✨ KPI Goals per Org-Chart Role ​

Define measurable targets for every role in your org chart and track progress in real time.

  • Role-scoped goals — each goal belongs to a role (CEO, Head of Operations, Field Sales Manager, etc.) and can have a numeric target, actual value, unit, direction (higher is better or lower is better), and a tracking period (annual, quarterly, monthly, or custom date range).
  • Progress status — each goal automatically computes On Track, At Risk, Achieved, or Not Started based on actual vs. target, pro-rated against elapsed period time. No manual status updates needed.
  • Goal inheritance — agents spawned for a role see the full ancestry chain of goals in their context (e.g., a field sales agent sees both their own targets and the regional manager's objectives above them).
  • Goals panel — a new Goals section in the web app shows your org chart's goal hierarchy, collapsible by level, with colour-coded progress bars and inline create/edit.

✨ Model Providers — Full Management UI ​

Complete UI for managing which AI models your agents use and how much they cost.

  • Provider list — add and manage any LLM provider: AWS Bedrock, OpenRouter, DeepSeek, Anthropic, OpenAI, or a custom endpoint.
  • Per-provider model catalog — add models, set $/MTok pricing, or fetch the model list automatically from the provider.
  • Per-agent routing — assign a specific provider and model to each agent. Set a global auxiliary LLM for system tasks separately.
  • Test connection — verify credentials and model availability before assigning to production agents.
  • Safe delete — see which agents are affected before removing a provider.

✨ Artifact Viewer — Smart File Rendering ​

Files attached to tasks are now rendered intelligently rather than shown as raw text.

  • JSON — collapsible interactive tree with click-to-expand nodes and syntax colouring.
  • CSV — rendered as a proper table with sticky header and row numbers (up to 2,000 rows).
  • YAML — line-by-line key/value/comment colouring.
  • XML — tag, attribute, and CDATA colouring.
  • Code files — language badge (Python, TypeScript, Go, and 10 more) with gutter line numbers.

🔧 UI Design System Overhaul ​

Major visual consistency pass across the desktop web app and mobile PWA.

  • Fixed several components that appeared broken in light mode (white-on-white, hardcoded dark hex values).
  • Resolved undefined CSS variable bugs that caused inbox and dashboard icons to have no colour.
  • Standardised all interactive states (hover, focus, active) using semantic design tokens.
  • Mobile PWA now uses the same design token system as the desktop app — consistent colours across devices.

July 4, 2026 ​

✨ Done Tasks Are Immutable — Clone to Continue Work ​

A completed task can no longer accidentally have its status changed back to Blocked, Running, or Triage. This protects audit trails and prevents history rewrites.

  • Locked status — the status chip on done tasks is replaced with a read-only 🔒 Done badge.
  • Clone to continue — a prominent ⧉ Clone button on every done task creates a new copy with the same title and description, ready for the next iteration.
  • Archive only — the only valid exit from Done is Archived (for cleanup). All other transitions are blocked at the API level.
  • Non-status fields remain editable — you can still edit the title, description, tags, and priority on a done task.

✨ Smarter Task Decomposer — Correct Agent Assignment by Default ​

When the decomposer breaks a complex task into subtasks, it now assigns the right agent by default instead of picking randomly.

  • Agents are scored against each subtask using keyword overlap, dataset access, and toolset relevance.
  • The agent roster is injected into the decomposer prompt so the LLM pre-assigns real profiles.
  • The "no match → random fallback" behaviour is gone — the best-scoring agent is always chosen.

✨ Hierarchical Agent Delegation ​

Agents with delegation authority can now only delegate to agents within their org-chart reporting chain, not to any agent in the org.

  • Delegation discovery respects the org hierarchy — a manager agent sees its direct reports and their reports, recursively.
  • Utility-tagged agents (knowledge managers, shared services) remain visible to everyone regardless of position.
  • Agents without a role in the org chart can only delegate to utility agents.
  • Token savings — leaf agents that never delegate no longer receive the full agent roster in their context.

✨ Jira Worklog Tools ​

Two new Jira tools: jira_get_worklog (fetch time entries on any issue) and jira_add_worklog (log time with Jira duration strings and optional comments). JQL search also now warns about reserved words (project keys like INT, ORDER, SELECT must be double-quoted).

🔧 Artifact Handoff Between Decomposed Tasks ​

Subtasks in a decomposition pipeline can now reliably read artifacts produced by sibling subtasks and the parent task. Upstream outputs are referenced by artifact ID in the agent's context — no more path guessing.

June 30, 2026 ​

🔧 Parent Tasks Stay Visible After Decomposition ​

When a complex task is decomposed into subtasks, the parent task now appears as Blocked — Waiting for Children on the kanban board. It auto-completes when all child tasks finish. Previously, decomposed parents disappeared from the board entirely.

✨ System Health Panel ​

A new System Health panel in Admin shows real-time service health, active task metrics, and CloudWatch log tailing — all from within the DMOps UI, without leaving the app.

✨ On-Demand Agent Delegation Discovery ​

A new list_delegatable_agents tool lets agents search for other agents by name, skill, tag, or role on demand — instead of injecting the full roster into every agent's context. Results include a matched_reason so agents understand why each candidate was suggested.

June 29, 2026 ​

✨ Wiki Knowledge Graph — 12 Phases Complete ​

A self-improving shared knowledge base for your entire agent team. All 12 planned phases are now live.

  • Shared knowledge — agents index documents, search with semantic similarity, ask questions, and receive cited answers from the shared wiki.
  • Knowledge manager agent — a dedicated km-agent curates the knowledge graph: merging duplicates, filling gaps, tagging stale pages, resolving orphans, and auto-consolidating overlapping content.
  • Automatic maintenance — daily and weekly scheduled jobs detect stale pages, orphaned articles, and near-duplicates. The km-agent resolves them autonomously.
  • Gap-to-page pipeline — when agents hit knowledge gaps repeatedly (≥3 times), the system automatically creates a task to fill that gap.
  • Graph traversal — agents can traverse the knowledge graph via BFS, find shortest paths between concepts, and explore entity relationships.
  • Session synthesis (Dream) — nightly, the system distils completed task sessions into structured wiki pages: entities, concepts, and decisions. Weekly pattern detection identifies recurring themes across synthesis pages.
  • Knowledge pre-fetch — optionally, relevant wiki pages are injected into an agent's context at spawn time so agents arrive already briefed.
  • Usage metrics — the dashboard tracks wiki consultations per 24h, unique agents, graph density, and open knowledge gaps.

June 26, 2026 ​

✨ Datasets — User-Defined Relational Storage ​

Create structured, queryable data tables directly inside DMOps and give agents controlled access to read and write them.

  • Schema editor — define tables with typed columns, set up saved views, and publish changes after human review.
  • Agent CRUD tools — agents can query, insert, update, and run SQL against datasets they've been granted access to (Tier 1: query/list, Tier 2: insert/update, Tier 3: delete/schema).
  • Desktop grid — high-performance virtualised data grid with server-side filter, sort, pagination, and CSV import/export.
  • Mobile read-only — browse published datasets and paginate through rows on mobile with search.
  • Human-gated publish — schema changes and bulk edits go through a Pending Changes review before becoming live.
  • 6 built-in datasets — pre-wired system datasets available on every tenant.

June 23, 2026 ​

✨ Task Run Limits — Prevent Runaway Agents ​

Every task now has a maximum runtime (default 10 minutes) and a maximum iteration count (default 90 turns). If an agent exceeds either limit, the task is moved to Blocked and partial outputs are preserved. Limits can be overridden per agent or per individual task.

✨ Tenant Tiers — Right-Sized Resource Profiles ​

Five compute tiers map directly to Fargate CPU/memory and concurrent agent limits:

TiervCPUMemoryMax Concurrent Agents
10.51 GB2
212 GB4
324 GB8
448 GB16
5816 GB32

Tiers can be changed via the fleet management tools with a guided rolling update.

June 2026 — Foundation Release ​

✨ Core Platform Shipped ​

The first production-ready release of DMOps.ai includes:

Task Board

  • Kanban board with columns: Backlog, Ready, Running, Done, Blocked, Archived.
  • Human-readable task IDs, priority levels, new-task form, and state machine enforcement.
  • Atomic dispatcher — tasks are claimed and spawned with no race conditions.
  • Scheduled tasks with cron templates and a 2-minute scheduler tick.
  • Approval gates — configurable rules auto-block tasks for human sign-off (spend limits, deploy day restrictions, scope changes, critical operations).

Org Chart & Agents

  • Human + AI org chart with roles, reporting lines, and approval chains.
  • Agent definitions — configure system prompt, skills, tools, model, runtime limits, and budgets per agent.
  • Scored agent-task matching — the dispatcher picks the best-fit agent for a task automatically.

Skills & Tool Governance

  • Skill catalog with versioning and approval workflow.
  • Three-state tool toggle per agent (on / off / approval-required).
  • Skill optimizer — periodic analysis suggests skill improvements based on execution history.

Inbox & Handoffs

  • Unified inbox aggregating approvals, budget incidents, artifacts, reports, and agent handoffs.
  • Artifact delivery to inbox by role — agents push outputs to the right human team.

Spending & Observability

  • Token spend dashboard with per-model pricing, per-task cost tracking, and role-level budgets.
  • Execution timeline — trace every task run: tools called, skills used, tokens consumed, time elapsed.
  • Chain-of-checksum audit log for tamper-evident task history.

Integrations

  • Jira — issues, sprints, comments, status transitions, worklog.
  • GitHub — repositories, pull requests, issues, commits.
  • Salesforce — accounts, contacts, opportunities, cases.
  • PostHog — product analytics events and feature flags.
  • Google Analytics 4 — traffic, conversions, and engagement metrics.
  • Google Search Console — search performance and coverage.
  • ERP LiveLink (DMS) — ERP sync log monitoring, post-process entries, depot/device status.
  • AgentMail — dedicated agent email inbox with send/receive.
  • Metricool — cross-platform social media analytics (11 platforms, 3 ad networks).

Web App & Mobile

  • Desktop SPA with full kanban, org chart, inbox, spending, observability, skills, datasets, wiki, and settings panels.
  • Mobile PWA with task board, task detail, comments, org chart, and inbox — optimised for field use.
  • Light/dark theme toggle (dark default).

DMOps.ai is built by Dynamics Mobile. For questions, contact your account team.