top of page

AgentCore Identity Adds Private CA Support

31 minutes ago
11 min read
Image from the source report. Source: aws.amazon.com.

Amazon Bedrock AgentCore Identity now supports private certificate authorities, letting agents connect to internal identity providers without replacing their existing certificate trust arrangements. AgentCore Identity private CA support addresses a specific enterprise integration barrier: an accessible authentication server can still present a certificate the service does not trust.

A certificate authority, or CA, issues certificates that establish which servers a client should trust. An identity provider, or IdP, authenticates clients and issues credentials for accessing protected resources. AWS described the support on November 18, 2026, explaining how organizations can connect agents to privately hosted authentication infrastructure.

The central tradeoff is operational. Enterprises gain another way to preserve their identity architecture, while taking responsibility for the certificates their agents accept. A publicly trusted certificate and an internally trusted certificate solve related problems through different trust arrangements. Supporting the latter brings certificate ownership, rotation, and change control directly into the agent deployment process.

What AgentCore Identity private CA support changes

The change lets AgentCore Identity trust an enterprise’s certificate authority when contacting a private identity provider. It addresses the encrypted connection used during authentication, rather than changing what an agent is authorized to do afterward.

Transport Layer Security, or TLS, encrypts network connections and authenticates the server presenting a certificate. A private authentication service can use TLS correctly while relying on a CA outside a client’s default trust collection. That difference can prevent authentication before the application evaluates any requested permissions.

According to AWS’s private CA support, administrators provide a public CA certificate through AWS Secrets Manager or Amazon S3. AgentCore Identity uses that material to validate connections to the IdP. The CA’s private signing key does not belong in that configuration.

AWS illustrates the capability with Keycloak, an identity platform, protecting an internal wiki interface. Its example uses AWS Private CA to issue the server certificate. The broader capability also supports existing enterprise authorities, third-party authorities, and self-signed root authorities.

That distinction matters for organizations evaluating the announcement. AWS Private CA provides an implementation path, but adopting that certificate service is not the purpose of the integration. The relevant question is whether AgentCore Identity can trust the authority already responsible for the enterprise’s authentication endpoints.

Consider a hypothetical engineering assistant that searches internal documentation after obtaining an access token. A token is a credential that a protected service evaluates before granting access. Even accurate search behavior becomes irrelevant if the assistant’s authentication connection fails before receiving that credential.

Private CA support addresses that connection problem. It does not establish that the assistant should read every document available through the wiki. Authentication connectivity and document authorization remain separate decisions, with separate owners and failure modes.

This is why the announcement deserves a narrower reading than a general agent security upgrade. It expands compatibility with existing enterprise infrastructure. It does not independently establish that an agent’s permissions, requested actions, or handling of retrieved information meet an organization’s requirements.

There is also a useful distinction between enabling deployment and proving deployment quality. A supported configuration gives engineering teams a route through an integration barrier. Evidence that the route works reliably still requires testing against the organization’s actual endpoints and operational practices.

For enterprise buyers, that makes the announcement relevant during architecture review. Teams can evaluate an additional supported connection pattern before deciding whether their identity infrastructure needs modification. They should avoid treating product support as evidence that their particular environment has already been validated.

Keeping an internal IdP shifts work to platform teams

The immediate beneficiaries are teams that want managed agent infrastructure to work with identity systems they already operate. The corresponding pressure falls on platform, networking, and identity administrators who must agree on the connection’s ownership.

An enterprise rarely evaluates authentication as an isolated application setting. Identity infrastructure often serves multiple systems, follows established change procedures, and belongs to a different team from the agent application. A new connection therefore creates coordination work even when it avoids a larger redesign.

The practical attraction is architectural continuity. An organization can assess whether its current private authentication arrangement fits the supported model. That gives it another option when comparing application changes, certificate changes, and changes to the way internal services are exposed.

Private hosting and certificate trust still answer different questions. Hosting determines where a service runs and how traffic reaches it. Certificate trust determines whether the connecting client accepts the server’s identity. Neither decision substitutes for the other.

AWS’s custom OAuth provider configuration reflects that separation. OAuth is an authorization framework through which applications obtain access tokens. The provider configuration includes identity settings alongside a private endpoint arrangement.

AWS documents managed networking and a self-managed VPC Lattice option. VPC Lattice is an AWS service for connecting applications and resources across private networks. The self-managed option supports cross-account connectivity, while the managed option reduces the resources customers must administer themselves.

Those choices affect responsibility as much as connectivity. A team choosing managed infrastructure still needs someone accountable for diagnosing failures. A team choosing self-managed infrastructure needs to justify the additional control against its own operational capacity.

For an agent developer, the desired outcome is straightforward: request the appropriate credential and call the intended resource. For an identity administrator, the same transaction raises questions about clients, issuers, certificate ownership, and change approval. Both perspectives are necessary for a durable deployment.

The pressure becomes visible during incidents. If authentication fails after a certificate change, application engineers need to distinguish a trust problem from a credential problem. Network administrators need enough context to determine whether traffic reached the intended destination.

That requires shared documentation before the incident. A diagram showing an agent and an internal application is insufficient if nobody records the authentication endpoints between them. The useful operational record identifies ownership and expected behavior at each connection.

Teams maintaining technical knowledge bases can apply the same principle to deployment records. Certificate references, approval decisions, and recovery procedures should remain searchable alongside application documentation. Sensitive credentials should stay in their designated storage systems.

The organizational implication is clear: private integration reduces some architectural friction while creating an explicit service dependency. Enterprise AI projects need identity and networking participation early enough to evaluate that dependency before rollout.

Certificate issuance and trust remain separate decisions

Issuing the IdP’s server certificate and configuring AgentCore to trust its issuer are separate operations. Keeping them distinct helps explain both the benefit and the maintenance burden of the new support.

AWS Certificate Manager, or ACM, manages certificates used by supported AWS services. AWS Private CA supplies a private certificate authority that can issue those certificates. An enterprise adopting that arrangement must decide how the authority fits its broader certificate hierarchy.

AWS’s private CA configuration supports root and subordinate authorities. A root establishes the top of a trust hierarchy. A subordinate receives authority from a parent and can issue certificates within that hierarchy.

The documentation also distinguishes general-purpose authorities from short-lived certificate mode. It describes renewal permissions through which ACM can renew eligible private certificates. These are certificate lifecycle choices, rather than agent reasoning features.

That separation matters when evaluating implementation effort. A demonstration can create an authority specifically for its example. A production enterprise should first determine whether an approved authority already exists and whether introducing another one fits its governance model.

Creating an additional CA establishes another source of trust that somebody must operate. Reusing an existing CA carries its own scope and ownership considerations. Neither choice should happen automatically because a tutorial uses a particular service.

The same reasoning applies to server certificates and CA certificates. A server certificate identifies an endpoint. A CA certificate represents an authority that the connecting service accepts as an issuer. Confusing them can turn a simple configuration task into a misleading diagnosis.

From an architecture perspective, trusting an issuer creates flexibility across routine server certificate replacement. The organization can preserve a stable trust relationship while managing endpoint certificates separately. That flexibility also means the authority’s issuance practices become relevant to the connecting service.

A certificate authority should therefore be evaluated as part of the authentication architecture. The application team needs to understand who can approve issuance and which systems rely on that authority. Those answers determine how broadly a certificate management mistake can matter.

AgentCore Identity private CA support makes this relationship configurable within the managed service. It does not remove the need to understand the relationship. The integration’s value depends on connecting that configuration to an existing ownership and review process.

This is also where procurement language can obscure engineering reality. A feature checklist might record private CA support as a completed requirement. An architecture review should ask which authority will be trusted, who operates it, and how changes reach the deployed provider.

The strongest evaluation separates those questions. Product compatibility establishes that a configuration is supported. Organizational readiness establishes that the enterprise can maintain it. Successful production use requires evidence for both.

Rotation turns stored certificates into deployment state

A certificate file’s location is not the same thing as the trust configuration currently used by the provider. This distinction is the most consequential maintenance detail in the announcement.

AWS’s private IdP documentation says AgentCore Identity retrieves certificate content during configuration. Replacing an S3 object or secret does not automatically refresh the provider. Administrators must update the provider to retrieve the changed material.

That behavior means rotation involves a deployment action, even when the storage reference stays unchanged. An operator cannot infer active trust solely from the current contents of the source. The relevant evidence includes the provider update and the connection’s subsequent behavior.

AWS requires a private endpoint and HTTPS. It accepts PEM-encoded CA certificates, a text representation of certificate data, within a bundle limited to 16,384 bytes. The configuration uses a single source entry, which can contain multiple CA certificates.

The documentation also preserves hostname checking. The server certificate must match the endpoint and chain to configured trust material. A private CA configuration does not authorize a connection to accept an arbitrary server identity.

For rotation, AWS describes updating the source and then updating the credential provider. Its announcement recommends overlapping old and new authorities during the transition. The operational objective is to establish new trust before endpoints depend exclusively on it.

The sequence matters because different parts of the system can change at different times. An administrator might publish new certificate material before another team updates a server. Without a coordinated transition, individually correct changes can still interrupt authentication.

A useful deployment review therefore asks what the system trusts at each stage. Before the transition, operators need a known working configuration. During the transition, they need evidence that the intended endpoints remain acceptable. Afterward, they need confirmation that obsolete trust has been removed.

AWS documents another important update behavior: omitting certificateConfigurations removes the saved private CA configuration. An unrelated provider change can therefore affect trust if the update request leaves out that field. Automation should preserve the settings administrators intend to retain.

This is a maintenance concern rather than an argument against the feature. Configuration interfaces need explicit semantics, and AWS documents this one. The responsibility falls on deployment tooling to implement those semantics consistently.

Certificate protection also demands attention to integrity. The public CA certificate is not a password, but unauthorized replacement changes a security decision. Storage write access and provider update access therefore deserve review as parts of the same operational process.

A narrowly controlled file offers limited assurance if an unrelated process can redirect the provider to another source. Conversely, controlled provider updates do not resolve unauthorized changes to the referenced content. Reviewing the complete change path produces a more useful assessment.

Organizations should also distinguish availability testing from trust testing. A successful token request shows that an intended path works. Testing an unacceptable certificate or hostname helps determine whether the system rejects the conditions administrators expect it to reject.

Those exercises should use an isolated environment with clear expected outcomes. Their purpose is to validate the enterprise’s configuration and recovery process. They should not become experiments against production authentication dependencies.

For AgentCore private CA explained in operational terms, the key point is straightforward: certificate trust becomes maintained deployment state. Teams need to know its source, its active contents, and the procedure for changing it safely.

The wider agent identity race does not erase trust boundaries

Private certificate support addresses compatibility with enterprise identity infrastructure, while broader agent identity platforms address additional governance questions. Those capabilities belong in the same evaluation without being treated as interchangeable.

Microsoft provides a useful comparison. Its agent identity model describes identities and blueprints in Microsoft Entra ID, Microsoft’s identity platform. The model separates agent representation, authentication, and permissions on downstream resources.

Microsoft’s documentation says new agent identities do not automatically receive downstream resource permissions. Administrators grant access through the target service’s authorization model. That distinction reinforces a principle relevant to AWS: identifying an agent and authorizing its actions are different responsibilities.

The comparison does not establish that either platform provides equivalent private CA functionality. It shows different parts of the enterprise agent identity problem. Product evaluations should compare documented behavior for the intended deployment, rather than infer feature parity from similar terminology.

For enterprises, preserving an existing identity system can be valuable even when another platform offers a more integrated identity experience. The decision depends on existing infrastructure, organizational ownership, and application requirements. A general platform ranking would conceal those differences.

There is also a distinction within AWS’s own services. AgentCore Gateway connects agents to tools and services, while the Identity configuration discussed here concerns authentication providers. Similar certificate fields do not guarantee identical permission models or runtime behavior.

AWS’s Gateway certificate controls illustrate why that distinction matters. Gateway target documentation assigns certificate retrieval to the gateway execution role. It also documents target-specific validation, expiry monitoring, and certificate revocation behavior.

For those Gateway targets, AWS says certificate revocation checks are not performed. Revocation is the process of withdrawing trust before a certificate expires. That documented behavior belongs to the Gateway target context and should not be generalized to every AgentCore connection.

The practical lesson is to evaluate each connection independently. An agent might contact an identity provider for credentials and a tool endpoint for application work. Each connection needs its own documented trust arrangement and operational expectations.

A security review should resist the phrase “private certificates supported” when it hides those distinctions. Which service reads the certificate, when it reads it, and how an update takes effect are all material questions. Their answers belong beside the architecture decision.

This also limits what the November announcement establishes. AWS describes functionality and an implementation example. It does not provide independent evidence of customer adoption, outage reductions, or performance gains across enterprise deployments.

The positive case is compatibility: enterprises gain a supported way to connect another part of their existing infrastructure. The skeptical case is maintenance: compatibility creates dependencies that must remain correct through changes. These positions are compatible rather than contradictory.

For AgentCore private CA explained as a buying decision, the relevant question is operational fit. Can the enterprise support the connection throughout its lifecycle? A successful initial demonstration answers only the beginning of that question.

What enterprise teams should watch next

The next useful evidence is repeatable operation through change, followed by clear deployment coverage and demonstrated use. Additional security terminology will tell buyers less than observable behavior.

The first signal is a documented rotation exercise against representative enterprise infrastructure. Teams should look for successful authentication before, during, and after the authority transition. They should also expect evidence that the previous authority is removed when the transition ends.

That would strengthen the case that the feature fits established certificate operations. Repeated manual recovery or unclear active trust would weaken that assessment. The important result is a procedure another qualified operator can reproduce.

A convincing exercise should include the routine administrative changes that surround certificate maintenance. Teams need to know whether deployment automation retains the intended trust settings. They also need a recovery path that does not depend on undocumented knowledge held by the original implementer.

The second signal is current documentation for the intended Region and networking arrangement. AWS ties the capability to support for private identity providers. Buyers should verify their actual deployment location rather than assume availability from a general service announcement.

Clear documentation across the intended arrangement would strengthen deployment confidence. Unresolved account boundaries, unsupported combinations, or conflicting instructions would narrow the practical benefit. These are deployment questions that need concrete answers before a production commitment.

Teams should also watch whether operational documentation remains consistent across related AgentCore services. Similar configuration names can encourage assumptions about identical behavior. Explicit service-specific explanations help administrators maintain the distinctions that the architecture requires.

The third signal is evidence from real deployments using existing enterprise identity infrastructure. Useful accounts would describe what remained unchanged, what required modification, and who maintains the resulting connection. Adoption claims without those details offer limited architectural guidance.

Such evidence would strengthen the argument that AgentCore Identity private CA support removes a recurring integration obstacle. Reports of substantial redesign would qualify that conclusion. Neither outcome can be inferred from the announcement alone.

The broader significance is practical: managed agents need to participate in enterprise systems whose trust arrangements already exist. Supporting those arrangements can reduce the changes required around authentication. It also makes certificate operations part of the agent service’s dependency chain.

Start with a representative private identity provider and identify the teams responsible for its networking, certificates, and client configuration. Review the supported connection pattern against that environment, then test authentication and certificate rotation before expanding the deployment. Record which trust material the provider uses and how administrators confirm an update took effect. Keep endpoint permissions separate from connection trust during the review. AgentCore Identity private CA support offers a concrete integration option; the next decision is whether your organization can operate it predictably. Ask the team approving the deployment to demonstrate that lifecycle, including recovery, before treating the integration as complete.

Get your work moving in remio

See what needs your attention and take the next step in Workspace.

remio currently supports Windows 10+ (x64) and Macs with Apple silicon.

Your AI Partner at Work
Get more done with remio

Plan. Create. Deliver.
All in one place.

bottom of page