AscentCore Insights HUB
Run a fleet of AI agents from one hub.
The HUB spawns Claude Code instances on demand, feeds them a queue of tasks, and collects every question they raise into one inbox. Schedule the whole orchestration to run unattended, inside your own perimeter and under your own credentials. Reasoning where you need it. Determinism where you don't.
Don't pay a reasoning model to re-think the same task 10,000 times. Fix the plan once, then let it run.
Point it at a queue. It spawns the agents and drains the backlog.
The HUB turns a backlog into finished work. Feed it a queue: Jira tickets, a list of repositories, a batch of documents, and it spawns a Claude Code instance per task, each isolated in its own ephemeral sandbox. Parallel branches run together, results route themselves, and the container is destroyed the moment the run ends.
- Spawn Claude Code on demand: one instance per task, running in parallel, each sandboxed and disposable
- Consume a queue of tasks (a Jira backlog, work items, or any list) and process it unattended at the concurrency you set
- Chain MCP calls, decision branches, AI steps, and coding agents into a single flow that routes on conditions without touching code
- Every action runs under the user's own identity and rights, traceable end to end in the live run history
Three ways to run. Same governed pipeline underneath.
Trigger a run from the web UI, a Slack slash command, or a REST call, and watch every step report what it is and what it did in real time.
Set any orchestration to run nightly, weekly, or on a custom cron. It wakes up, does the work, delivers the result, and shuts down, with no one watching.
Attach a task queue and the HUB consumes it item by item, spawning agents, running workflows, and draining the backlog until it's empty.
When an agent needs a decision, it asks here, not in a terminal you're not watching.
Autonomous agents stall the moment they hit a real question: which approach, confirm this change, which ticket, a missing credential. The HUB collects every question from every running agent into one place. Answer it once, in the web UI or a Slack thread, and the agent picks up exactly where it paused.
- One inbox for every running agent, with no switching between terminals, tabs, or sessions to keep work moving
- Answer in the web UI or reply in Slack; the agent resumes on your response, in context
- Missing-credential requests route to the Vault flow: you approve, the credential is leased for that run only, then revoked
- Nothing blocks silently: what's pending, who's waiting, and for how long are all visible at a glance
Build the pipeline once. Validate it once. Trust it forever.
The agents the HUB spawns run alongside deterministic workflows you build here. Drag blocks onto a canvas and connect them into a Directed Acyclic Graph. Data flows node to node, and the same inputs always produce the same structured output. No drift, no surprises, no re-planning on every run.
- Visual, no-code canvas: domain experts build their own automations, not just engineers
- Deterministic by design: suitable for finance, compliance, QA, and operations
- Iterator & Aggregator patterns process millions of rows, then stack the results
- Publish as a scheduled job, REST API, chatbot, or Slack command, then register it in the HUB for agents to call
Register every agent, tool server, skill, and credential in one catalog
Claude Code, MCP servers, reusable skills, and workflows all register once in a single catalog, and any orchestration can then call them by name. Vault-backed credentials are leased to a run only for its duration and revoked the moment it ends. Credentials are never at rest.
Plus a growing catalog of MCP servers and reusable skills, registered once, reused everywhere, and monitored for health in real time. If a model endpoint goes down or a credential expires, the HUB reflects it immediately.
90+ building blocks. Every step of a process, ready to drop on the canvas.
When you add a step, you pick a category and an action. Each block is documented, versioned, and does exactly one thing, deterministically. Here's what the library covers.
Data Sources & Import
Load documents, call any REST API, scrape pages, or read straight from your systems of record.
AI & Agents
Spawn coding agents, embed an LLM at any node, add RAG memory, or call registered agents and MCP tools.
Process & Transform
Filter, dedup, merge, split, chunk, and reshape: pure, repeatable operations with no model in the loop.
Jira & Integrations
The deepest Jira coverage in the library: read, write, transition, link, and manage R4J & XRay, plus Jenkins CI/CD.
Code Analysis
Clone, search, and diff repositories, then run dependency impact analysis and CVE scans at a fraction of agent cost.
Logic & Control
Conditionals, iterators, jumps, state variables, queue consumption, and human-in-the-loop review, the flow control that makes runs predictable.
Testing & QA
Generate structured, traceable test cases from requirements, with deterministic coverage planning and Figma vision grounding.
Search & Knowledge
Build a vector or knowledge-graph index from your own content, then query it semantically inside a workflow.
Results & Output
Export files, generate Markdown reports, publish REST endpoints, or email results, the last mile of automation.
Pay only for the AI that earns its place
Trailing-30-day usage from a live enterprise deployment. Most steps run on local models at zero inference cost; premium models and coding agents are reserved for the work that truly needs them.
An autonomous agent re-thinks. A deterministic executor just runs.
Both have a place. The trick is knowing which to use where, and the HUB lets you use both in the same flow, spawning a coding agent only when the task genuinely needs one, and running a fixed pipeline for everything else.
An autonomous agent, every request
- Re-plans from scratch: what do I need, where is it, how do I get it
- Burns premium tokens on thinking, every single run
- Can decide differently each time, with unpredictable output
- Stalls in a terminal no one is watching when it hits a question
An Insights orchestration
- The plan is fixed once, when it's built, and the HUB just executes it
- Deterministic steps re-run for free; agents are spawned only where reasoning pays off
- Same input, same output, every time, fully auditable
- Every agent question lands in one inbox, so nothing blocks silently
Reasoning is expensive. Repetition should be free.
Leave the deterministic steps to the deterministic executor.
Insights and the AI Hub, running at SiriusXM
At SiriusXM, Insights and the AI Hub run as two layers. Insights is turning manual, structured work into deterministic, audited workflows that execute inside SiriusXM's own environment, with multi-LLM routing. Scheduled workflows run 6M+ operations that cuts task creation by ~60-85%, testing time by 40% and escape duplicate requirements by 95%. The AI Hub is the "coordinating" layer above it: instead of a person kicking off each run, it triggers, schedules, and reports on agents and coding tools autonomously, running them in parallel, 24/7, and collecting the questions raised across active Claude Code instances into one UI for human-in-the-loop answers, then chaining each completed step into the next. In a live orchestration it processes
The Insights AI Hub gives us an orchestration layer on top of the Claude APIs that coordinates our Glean OK2 agents across the whole workflow. By decomposing work into reusable skills, sub-agents, and externally orchestrated steps, it gets us past individual context-window limits without sacrificing governance or human oversight. The result is far more consistent output across hundreds of OK2 initiatives, with much less manual intervention.
The scheduler pulls each item from the queue and runs four agents in parallel, 24/7, with a person needed only for the one-time setup. Same 1,139 items, same compute, no engineer tethered to the trigger.