AgentCore
Get started

The multi-agent AI platform by CoreOps.AI Put AI to work. Get your time back.

Building AI agents that take on repetitive work, self-service cloud compute, the full ML lifecycle and legacy modernization, on one platform. Teams move faster, and every step stays governed and traced.

Get started Explore the products

One platform. Faster delivery. Full control.

See it in action

One workspace for every team

Platform engineers, data scientists, agent builders and modernization teams share one workspace instead of a tool each.

Every project at a glance

Compute, data, experiments, agents and live models for a project, on one screen.

AgentCore · Retail Analytics

Every project at a glance: Compute, data, experiments, agents and live models for a project, on one screen.

Product screens shown with sample data.

Works with the stack you already run

Pick the model per agent, keep your vector store, your clouds and your identity provider. Anything else is one MCP server or HTTP tool away.

  • Anthropic Claude
  • OpenAI
  • Ollama
  • Groq
  • OpenRouter
  • Cohere
  • Voyage
  • Qdrant
  • Chroma
  • MCP
  • AWS
  • Google Cloud
  • Azure
  • On-premise
  • PostgreSQL
  • MySQL
  • Apache Airflow
  • Apache Pulsar
  • Okta
  • Azure AD

What this is

One platform instead of ten tools

AgentCore is one platform for the AI work most companies are trying to stitch together from separate tools. Build AI agents that act on your data, documents and models. Run machines, storage, vector databases and private AI models across AWS, Google Cloud, Azure or your own data centre. Take data all the way to a trained model in production. Rebuild legacy applications and prove the new one behaves the same.

Because it all lives in one workspace, teams stop waiting on each other. An analyst's question no longer becomes a ticket, a data scientist no longer waits days for a GPU, and an agent one team builds can be reused by the next. The controls large companies need are built in too, so moving fast never means starting a separate security project.

Three products, one platform

Less waiting, less rework, more of your people's time back

AgentCore brings an enterprise AI agent platform, MLOps tools with self-service cloud compute, and legacy code modernization together in one workspace, so teams stop waiting on each other. Slide through to see what each one changes.

  • Agent Studio

    AI agents that take work off your plate

    For operations, finance, support and product teams

    • Multi-agent teams that work on your data, models and documents
    • Draft a new agent from a plain-English description
    • Start from over 200 pre-built agents

    Today

    Requests queue behind analysts and engineers, and routine work eats into every team's week.

    With AgentCore

    People ask in plain language. The agent does the legwork and shows every step it took.

    Efficiency
    Routine requests are handled in one conversation instead of a chain of tickets.
    Profitability
    One enterprise AI agent platform covers agents, document search, testing and monitoring, and the cost of every run is tracked.

    Built in

    The Builder Assistant drafts a full agent from one description

  • ML Ops

    End-to-end MLOps, from raw data to production

    For data science, ml and platform teams

    • Automated ML pipelines from your databases and files
    • Data quality checked on every load
    • Experiment tracking and one-step model deployment
    • Self-service GPUs, storage and vector databases, in any cloud or on-premise

    Today

    Data pulled by hand, days waiting for a GPU, models trained on laptops, and few of them ever reach production.

    With AgentCore

    Pipelines run on a schedule, every experiment is recorded, and the best model ships in one step.

    Efficiency
    Self-service GPUs replace IT tickets, only new rows move on each load, and unchanged data is never re-checked.
    Profitability
    More models reach production, idle machines are easy to spot and stop, and open models on your own machines avoid per-token fees.

    Built in

    Batch-train several models, compare them side by side, promote the winner

  • Code Modernization

    Rebuild legacy apps and prove nothing broke

    For cios and engineering leaders with legacy systems

    • Gets the old application running again, as it is
    • Drafts the rewrite plan from the running system
    • Rebuilds on a modern stack and checks every screen matches

    Today

    Rewrites run over time and budget because nobody can prove the new system behaves like the old one.

    With AgentCore

    Data and screens are compared record by record and pixel by pixel before anyone cuts over.

    Efficiency
    The rewrite plan is drafted from the running system itself, not from months of discovery workshops.
    Profitability
    Retire expensive legacy platforms sooner, with less risk of a failed migration.

    Measured on a sample app

    12 of 12 screens matched · 100% data parity · 15-story plan in about 52 seconds

Savings estimator

What does repetitive work cost you today?

Think of the requests, data pulls, report runs and hand-offs your teams repeat every week. The example inputs below are placeholders; change them to yours.

25%

Your own estimate of how much of that work agents, pipelines and self-service could take on.

Returned to your teams each year

$86,250

1,725 hours freed for higher-value work

Hours spent on this work today
6,900 h
What those hours cost today
$345,000
Share handed to AgentCore
25%

People × hours per week × 46 working weeks × cost per hour × share. An estimate from your own inputs, not a quote or a guarantee; platform and cloud costs are not included.

Why AI work is still slow

AI pilots are easy. Getting real work out of them isn't.

Most teams can build a demo in an afternoon. Turning it into something that saves hours every week is where projects stall.

  1. 01

    Everyone is waiting on someone

    Data requests queue behind analysts, compute requests behind IT and model releases behind engineering. A ten-minute task turns into a week of hand-offs.

  2. 02

    Too many tools that don't talk

    Agents in one tool, models in another, pipelines in a third and a console for every cloud. People spend more time moving between tools than doing the work.

  3. 03

    Pilots never reach production

    Connecting an agent or a model to real systems takes months of glue code, so most pilots stop at the demo and the time savings never arrive.

How it works

Building AI agents your users can rely on, in four steps

You describe the job. AgentCore handles the loop, the integrations, the testing and the rollout, so your team spends its time on what the agent should do, not on wiring it up.

  1. 01

    Describe the agent

    Give it a persona, a model and memory. Start from a ready-tuned template, or describe the job in plain English and the Builder Assistant drafts the whole definition for you to review.

    No graph to draw
  2. 02

    Give it knowledge and tools

    Bind document collections and every binding becomes a retrieval tool. Add builtin tool packs for your data, models and cloud, saved workflows, other agents, or any MCP server.

    Tools are just schemas
  3. 03

    Prove it before it ships

    Write eval cases once: which tools it must call, which it must never call, the shape of the answer, a judge's rubric. A version that regresses cannot be promoted to production.

    Regression-gated
  4. 04

    Deploy, watch, roll back

    Every save is an immutable version. Send a slice of traffic to a canary, watch live traces with tokens and cost per step, and flip back to the last good version in one click.

    Canary + rollback

What you get

Everything between a prompt and a production agent

Most agent tooling stops at the reasoning loop. As an enterprise AI agent platform, AgentCore ships the parts you would otherwise build yourself: the integrations, the knowledge layer, testing and the release process.

Reaches your platform

Agents that act on your systems, not a sandbox

Builtin tool packs wire agents straight into the data, models and infrastructure your teams already run. The model sees a name, a description and an input schema; how the tool is implemented stays out of its way.

  • Query datasets and schemas with read-only SQL, straight from a conversation
  • Start training runs, read their metrics and deploy the winner
  • Run Python or shell in a sandboxed compute container, never in the runtime
  • Call your own APIs over HTTP with domain allow-lists, or any MCP server
Knowledge on tap

Answers from your own documents, in seconds

Drop in documents and AgentCore extracts, chunks, embeds and indexes them into a collection. Bind the collection to an agent and it gets a retrieval tool, scoped by chunk-level access control to what the asker is allowed to see.

  • Hybrid retrieval: dense vectors fused with BM25, then cross-encoder rerank
  • Contextual, parent-document and sentence-window strategies when you need them
  • OCR, tables and images from PDFs, Word documents and scans
  • Built-in retrieval evals: precision, recall, MRR and groundedness
  • Host the vector database yourself (Qdrant, Chroma or pgvector), right beside your models
Multi-agent by design

Multi-agent AI, with agents that delegate to other agents

Any agent can be a tool for another, with its own budget. A planner hands work to specialists and the whole run comes back as one nested trace, so you can see which agent did what and what each part cost.

  • Sub-agents carry their own step, token and cost budgets
  • Nesting depth is capped, so delegation cannot run away
  • Expose any agent as an MCP server that other agents and MCP clients can call
  • Deterministic steps stay deterministic: back a tool with a saved workflow
Ship it like software

Ship improvements often, roll back in one click

Agents change: prompts get tuned, tools get added, models get swapped. As an AI agent deployment platform, AgentCore treats every change as a release, so nothing reaches users until it has passed the same tests as the version it replaces.

  • Every save is an immutable version you can pin and redeploy
  • Eval cases assert on tool use, answer shape and an LLM judge's score
  • Route a share of traffic to a canary before promoting to production
  • A version that regresses is blocked unless someone explicitly overrides

The work that used to wait

Say the outcome. The agent does the legwork.

Each of these used to be a ticket to a different team and a week of back-and-forth. Now it is a sentence.

  • Retrain churn on last month's data and promote the winner.

    Head of ML

  • Which vendor invoices break our three-way-match policy?

    Finance controls

  • How many enterprise accounts renewed late this quarter, and why?

    Revenue operations

Who it's for

One platform, every team's agents

Each team builds the agents it needs on one shared platform, so what one team builds, the next can reuse instead of starting from zero.

  • For data and ML teams

    Train, compare and promote models from a conversation, with MLOps tools that cover the whole ML lifecycle. Agents work on your compute and can pause for sign-off before anything is deployed.

    Machine learning

  • For platform teams

    Let agents check instances and buckets across AWS, Google Cloud, Azure and on-premise, and handle bucket files, so routine infrastructure requests stop landing on your desk.

    Infrastructure

  • For knowledge-heavy operations

    Policies, contracts, SOPs and runbooks become cited answers, filtered to what each person is allowed to read. No more searching five drives for the current version.

    Operations

  • For document processing

    OCR, classify and extract fields from forms and IDs, check confidence, and route anything uncertain to a person. Every run shows exactly what each step saw and produced.

    Documents

  • For the questions in between

    Analysts get an agent that can read the schema, write the read-only query, run it and explain what the numbers mean, in minutes rather than days.

    Analytics

  • For customer support

    An assistant that answers from your help centre, drafts replies and hands the tricky cases to a person, so your team spends its time where it counts.

    Support

What changes

More done, without losing control

Fewer hand-offs, less waiting and less glue code, with every step still governed, so the hours go back into the work only your people can do.

One platforminstead of a tool per team
Agents, data, models and cloud in one workspace with one login, so nobody loses time switching tools or chasing access.
Minutesto a first agent draft
Describe the job in plain English or start from a template, and the Builder Assistant drafts the agent for you to review.
One stepfrom best model to live endpoint
Batch-train, compare and promote the winner to a serving endpoint, without handing it to another team.
Every runtraced and governed
Time, tokens and cost on every step, plus who asked and who approved, so speed never comes at the cost of oversight.

Why AgentCore

Not another chatbot builder. A platform for agents that act.

What AgentCore does that a workflow tool, an agent framework or a hosted agent builder doesn't do on its own. Pick any one to see what's behind it.

Built on the platform it acts on

Agents reach your data, models and cloud through first-class tool packs.

AgentCore does not try to win on connector count. It sits on the same platform that runs your datasets, training and infrastructure, so agents get deep, typed access to those systems, and a generic HTTP and MCP path for everything else.

  • Tabular data, model registry, deployments and buckets, all as tools
  • Knowledge bindings become retrieval tools automatically
  • Trained models become typed prediction tools, with their feature names

knowledge + model bindings

"knowledge": [
  { "label": "policies", "auto_retrieve": true,
    "top_k_default": 5 }
],
"models": [
  { "label": "churn", "kind": "predict",
    "features": ["tenure", "monthly_charges"] }
]
// → rag.retrieve_policies, model.predict_churn

How it compares with the usual options

CapabilityWorkflow buildersAgent frameworksHosted agent buildersAgentCore
Unit you buildA flowchartA graph in codeA closed agentAn open agent, plus workflows
Who decides what runsYou, in advanceYou, in codeThe vendor's loopThe model, within limits you set
Evals that block a bad deployNot includedAdd-onLimited Built in
Sandboxed code executionPluginNot includedNot included Built in
Training and model deploymentNot includedNot includedNot included Built in
Multi-tenant orgs and projectsLimitedNot includedPer cloud account Built in

Governed by design

Move fast without losing control

Guardrails run on every tool call, risky actions wait for a human and every step is traced. It is all built in, so teams get speed and oversight together, without a separate security project.

  • Guardrails on every tool call

    Allowed domains, output checks and hard budgets on steps, tokens and spend run on every call, automatically.

  • Humans approve the risky steps

    Mark any action as approval-required and the run waits for a person. Personal data is redacted before it leaves.

  • A full audit trail

    Every run is traced step by step, and actions across the platform land in a searchable, org-scoped audit log.

  • Sign in the way you already do

    Single sign-on with Azure AD, Google, Okta, SAML or OIDC, with users and groups synced from your directory.

  • Access that carries over

    Agents work with the permissions of the person using them, so nobody sets up access twice and nothing gets more than it should.

  • Your cloud or your data centre

    Everything runs on machines you control, in AWS, Azure, Google Cloud or on-premise. Keys are encrypted, never pasted into agent settings.

Questions

What people ask us first

What does AgentCore actually do?

It takes repetitive work off your teams. You build AI agents that act on your company's systems, not just chat: describe the job, its tools and its knowledge, and AgentCore runs it against your data, models and cloud, recording every step with its time and cost. Versions, tests and gradual rollouts make improving an agent quick and low-risk. The same platform also runs your cloud infrastructure, MLOps and legacy code modernization, so teams stop switching between tools.

How quickly can a team get started?

Start from one of over 200 pre-built agents, or describe the job in plain English and the Builder Assistant drafts the whole agent for you to review. Bind a document collection or a dataset and the agent can use it straight away; for the systems AgentCore already covers, there is no separate integration project.

What makes AgentCore a multi-agent AI platform?

Any agent can call other agents as tools. A planner hands work to specialist agents, each with its own step, token and cost budget, and the whole run comes back as one nested trace that shows which agent did what and what it cost. Nesting depth is capped, so delegation cannot run away.

Is AgentCore an end-to-end MLOps platform?

Yes. Alongside agents, AgentCore is an end-to-end MLOps platform for enterprises. Automated pipelines ingest and quality-check your data, every training run is tracked with its data version, configuration and metrics, and the winning model is deployed to a serving endpoint in one step, all on your own compute. That covers the whole ML lifecycle in one place.

What can an agent connect to?

Out of the box: tabular datasets and read-only SQL, the experiment and model registry, deployed models, buckets and files across AWS, Google Cloud and Azure, sandboxed Python and shell, web search, and your document collections. Beyond that, an HTTP tool restricted to the domains you allow, any MCP server, saved workflows, and other agents. That includes ERP systems such as SAP, connected through their APIs or an MCP server.

How is an agent different from a workflow?

A workflow is a fixed flowchart: you decide every branch in advance. An agent is given a goal, a set of tools and limits, and the model chooses which tools to call and in what order. AgentCore supports both. Use an agent when the path depends on what it finds, and back a tool with a saved workflow when a step must run the same way every time.

Which models can we use?

Each agent picks its own provider and model. The agent runtime launched on Anthropic Claude and also supports OpenAI. For chat workloads, LLMCore adds open models served by Ollama on your own VMs, as well as Groq and OpenRouter. Keys can be set per project and are stored encrypted.

How do we know an agent is good enough to ship?

Write eval cases next to the agent: an input plus assertions such as which tools must or must not be called, the shape of the answer, text it must contain, a token budget, or a minimum score from an LLM judge. Cases run against every version, and a version that regresses against production cannot be promoted without an explicit override. Collections have their own retrieval evals too.

Can other systems call our agents?

Yes. Besides chat, your own apps can call an agent with a scoped agent API key, and any agent can be published as an MCP tool so other agents and MCP-aware clients can use it, under the caller's own identity.

How do we stop an agent from doing something it shouldn't?

Several layers. It can only use the tools you attach. Every call is checked against the permissions of the person who asked. Any tool can be marked approval-required, which pauses the run until someone approves it. HTTP calls are limited to allowed domains, outputs can be redacted for PII, and each run has a hard budget on steps, tokens and cost, with sub-agent nesting capped.

Where does it run, and where does our data go?

AgentCore is a set of containerised services. Training, document indexing and code execution run on compute agents that sit on machines you control: in your AWS, Azure or Google Cloud accounts, or on-premise in your own data centre, and data moves between services through short-lived signed URLs. Talk to us about the deployment model that fits your security requirements.

See how much time AgentCore gives back

Pick one repetitive task, hand it to an agent, and measure the hours it saves.

Get started