CloudThinker Connections: How We Securely Connect to Your Infrastructure

Your databases live in private subnets and your clusters sit behind firewalls. How CloudThinker Connections reaches them today: 99 built-in connections plus custom MCP, an egress IP allowlist or an environment inside your network, credentials injected only when a command runs, and an audit log of every action.

Updated Nov 2, 2026

Cover Image for CloudThinker Connections: How We Securely Connect to Your Infrastructure

CloudThinker Connections: How We Securely Connect to Your Infrastructure

A technical guide to CloudThinker's connectivity architecture: four network options from public HTTPS to a deployment inside your own network, scoped credential management, and the security controls that let AI agents work on your infrastructure without weakening your security posture.


A security review for any new operations tool usually ends at the same diagram. The production database sits in a private subnet with no route to the internet. The Kubernetes API server has a private endpoint. The on-premise warehouse is reachable only over the corporate VPN. Then the vendor's onboarding guide asks for an inbound rule from 0.0.0.0/0, or an admin API key, or an agent installed on every host with root. The review stops there, and so does the project.

AI-powered cloud operations are only as useful as the infrastructure they can reach. Your network rules, IP restrictions and compliance controls took months to put in place. You're not going to punch holes in all of that for an AI platform.

CloudThinker Connections exists to solve that. The question isn't "how do we integrate with AWS". It's how we reach your infrastructure through the network architecture you already have, without asking you to lower your guard. The answer is four network options, from simple public access to a deployment that runs inside your own network, and one set of credential and audit controls that applies to all of them.


Why the usual integration patterns break

Most tools reach private infrastructure in one of three ways, and each one fails a security review for structural reasons.

Open the endpoint. Give the database or cluster a public address and restrict it later. The restriction tends to be "later" forever, and the endpoint shows up in the next external attack-surface scan.

Install an agent everywhere. A daemon on every host with broad local rights solves reachability by moving the trust problem inside your network. Now you're patching, upgrading and auditing someone else's privileged software on every node.

One admin credential. A single broad key is the fastest way to make an integration work. It's also impossible to scope after the fact, and when it leaks, everything it touched is in play.

The pattern underneath is the same: the integration decides how much access it needs, and your network bends to fit. Connections turns that around. You pick the network path. You create the credential, scoped to what a skill actually needs. CloudThinker injects it only when a command runs.


Architecture overview

Every CloudThinker connection follows the same pattern: a skill needs access to a system, and a connection provides that access through a secure, audited channel.

01Request

CloudThinkerCloudThinker

  • SkillNeeds data from one system
  • SandboxCommands run in the managed sandbox
  • CredentialInjected only when a command runs
  • AuditActions recorded in Audit Logs

On demand, never shown in chat

02Network path

Your choice of path

  • PublicHTTPS
  • Allowlist IPCloudThinker egress IPs
  • EnvironmentInside your network (beta)
  • Self-hostedIn your own cloud (early access)

Mix options per service

03Your infrastructure

Where it lives

  • AWSCloud accountsIAM role
  • KubernetesClustersService account, namespaced RBAC
  • PostgreSQLDatabasesSELECT-only user
  • GrafanaObservabilityRead-only API token

Scoped by credentials you create

Every connection follows the same pattern. Only the network path changes.

The architecture is deliberately simple. Connections are on demand: the credential is injected into CloudThinker's managed sandbox only when a command runs, it can do no more than the permissions you gave it, and actions are recorded.

What varies is the network path between CloudThinker and your infrastructure. That's where the four options come in.


Four network options

Each option fits a different set of network policies. Connections run from CloudThinker Cloud, so the first two reach services that accept connections from the internet. The last two keep the work inside your network.

01Option 1

Public

HTTPS straight to public APIs and SaaS tools. Set up in minutes.

02Option 2

Allowlist IP

Same encrypted path, gated to CloudThinker’s egress IPs.

03Option 3

Environment

A machine inside your network that dials out. No inbound port.

04Option 4

Self-hosted

CloudThinker inside your own cloud, linked to your data center.

Four network options, from the simplest to the most isolated. Choose per service.

Option 1: Public (direct HTTPS)

The simplest option. CloudThinker connects to your service over the public internet using HTTPS.

Best for:

  • Cloud services with public APIs (AWS, GCP and Azure management APIs)
  • SaaS tools (Datadog, PagerDuty, Jira, Slack)
  • Development and staging environments
  • Teams getting started with CloudThinker

How it works: CloudThinker makes HTTPS requests directly to your service endpoints. All traffic is encrypted in transit. Authentication uses standard credentials: API keys, OAuth tokens or IAM roles.

Setup time: Minutes. Enter your credentials, test the connection, done.

Option 2: Allowlist IP

For organizations that restrict inbound access by source IP, CloudThinker gives you its egress IP addresses to add to your allowlists.

Best for:

  • Databases with IP-based firewall rules
  • Infrastructure behind security groups that restrict source IPs
  • Network policies that require known source addresses
  • Compliance requirements that mandate IP-level access control

How it works: connection traffic leaves CloudThinker Cloud from a known set of egress IPs. You add those IPs to your security groups, NACLs or firewall rules. Traffic is still encrypted with TLS, and the allowlist adds a network-layer gate on top. Never expose a service that has no authentication.

On AWS, that's one rule per address on the security group in front of the service:

aws ec2 authorize-security-group-ingress \
  --group-id sg-0a1b2c3d4e5f67890 \
  --protocol tcp \
  --port 5432 \
  --cidr <cloudthinker-egress-ip>/32

Setup time: Add CloudThinker's egress IPs to your allowlist, then configure credentials as normal.

The egress IP list isn't published. To get it for allowlisting, contact our team.

Option 3: An environment inside your network (beta)

For services that must stay private, run an environment: a folder on a machine you run inside your network (a server, a VM or a CI runner) where CloudThinker can read files and run commands. The worker process connects outward over HTTPS, so no inbound port is opened.

Best for:

  • Production databases in private subnets
  • Internal tools with no public endpoint, such as vCenter, Prometheus or Argo CD
  • Organizations with "no inbound from the internet" network policies
  • Teams that want the agent working next to their own tools

How it works: install the CloudThinker CLI (beta) on the machine, create the environment and start its worker process. Install the service's own command-line tool (for example psql) and its credentials on that machine, and the agent's shell uses them there. An environment doesn't make a workspace connection private: commands that use a workspace connection still run in CloudThinker Cloud. Shell commands in an environment aren't sandboxed, so run it under a dedicated, non-admin account that can reach only what you intend.

# On a host inside the private network (the CLI is in beta, so flags may change)
cloudthinker worker outpost create payments-db --shared
cloudthinker worker start --outpost payments-db --workdir "$PWD"

What this means in practice:

  • Your RDS instance stays in a private subnet with no internet route
  • Your EKS cluster doesn't need a public endpoint
  • Nothing listens for inbound traffic: the worker process dials out
  • You decide which tools and credentials exist on the connected machine

Setup time: Install the CLI, start the worker process, and add the tools it needs.

Environments are in beta. The Environments guide covers what an environment can reach.

Option 4: Dedicated or self-hosted deployment (early access)

For on-premise infrastructure, hybrid estates or the strictest network requirements, CloudThinker can run inside your own cloud account.

Best for:

  • On-premise databases and legacy systems
  • Hybrid cloud architectures (cloud plus data center)
  • Organizations with mandatory private-network policies
  • Regulated environments that need the platform inside their own boundary

How it works: in a dedicated or self-hosted deployment, CloudThinker runs in your AWS, Azure or GCP account, and commands run on a sandbox node group kept apart from the platform. Your data center connects over Direct Connect, ExpressRoute, Cloud Interconnect or VPN. Inside your cloud, the platform reaches provider services through your own private endpoints (VPC endpoints on AWS, Private Link on Azure, Private Service Connect on GCP).

What this means in practice:

  • Your on-premise PostgreSQL server is reachable over the link you already run to your data center
  • Your data center firewall only needs to allow your own cloud network, with no broad internet rules
  • Traffic to cloud provider services stays on your own private endpoints
  • The platform runs inside the boundary your security team already audits

Setup time: Planned with CloudThinker's infrastructure team.

Dedicated and self-hosted deployments are in early access. Contact us to plan one.


Security at every layer

Whichever option you choose, every connection enforces the same controls.

01Start

Read-only

Start with a read-only credential. Writes go through Auto Mode.

02Scope

Least privilege

Each credential covers the minimum the skill needs.

03Storage

Encrypted

Encrypted at rest, never shown in chat, rotatable and deletable.

04Execution

Sandbox

Commands run in the managed sandbox, with credentials injected per command.

05Record

Audit trail

Audit Logs on Scale and above. Nobody can edit or delete an entry.

The same five controls apply on every option.

Read-only to start

Start every connection with a read-only credential. CloudThinker can then query your databases, inspect your infrastructure and analyze your metrics, but it can't modify, delete or write anything the credential doesn't allow.

This is enforced at the credential level. A connection isn't read-only on its own, and many connections have an Allow writes switch that starts on, so the IAM role, service account or database user you provide is what determines what CloudThinker can do. It never asks for more than a skill requires.

Read-only credentials are the floor. When a write is granted, CloudThinker acts within Auto Mode, so you decide what runs on its own and what waits for approval. A credential with write rights is a ceiling on what's possible, not a decision about what actually happens.

Scoped credentials (least privilege)

Each connection uses credentials scoped to the minimum access required:

  • AWS: IAM roles with specific policy boundaries, never admin access
  • Kubernetes: Service accounts with RBAC limited to target namespaces
  • Databases: Database users with SELECT-only grants on specific schemas
  • Monitoring: API tokens with read-only dashboard and metric access

For Kubernetes, a namespaced read-only role looks like this:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: cloudthinker-read
  namespace: payments
rules:
  - apiGroups: ['']
    resources: ['pods', 'pods/log', 'services', 'events', 'configmaps']
    verbs: ['get', 'list', 'watch']
  - apiGroups: ['apps']
    resources: ['deployments', 'replicasets', 'statefulsets']
    verbs: ['get', 'list', 'watch']
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: cloudthinker-read
  namespace: payments
subjects:
  - kind: ServiceAccount
    name: cloudthinker
    namespace: payments
roleRef:
  kind: Role
  name: cloudthinker-read
  apiGroup: rbac.authorization.k8s.io

Note what's missing: secrets, and any verb that writes. When you create a connection, CloudThinker tells you exactly which permissions are needed and why. No hidden scopes, no broad wildcards.

Encrypted credential storage

Connection credentials are encrypted at rest. Credentials are:

  • Never shown back in chat, and audit entries leave out the value
  • Never shared across organizations or workspaces
  • Rotatable at any time, without reconfiguring skills
  • Deletable: remove a connection and CloudThinker stops using its credential

Sandbox isolation

Every time a connection is used, the command runs in CloudThinker's Sandbox. Credentials are injected there only when a command runs, never sent to an environment, and never shown back in chat.

Even if an operation fails or behaves unexpectedly, the sandbox boundary keeps your credentials and infrastructure isolated.

Audit trail

On Scale and above, Audit Logs record user, agent and system actions across the organization, including connection changes. Nobody can edit or delete an entry. Entries are kept 90 days, and you can export them as CSV for compliance review.


One connection, end to end

Here's an illustrative case: connecting a production PostgreSQL database behind an IP allowlist, so CloudThinker can investigate slow queries.

1. Create a read-only user. Grant only what the investigation needs, and make read-only the session default as a second guard:

CREATE ROLE cloudthinker_ro LOGIN PASSWORD '<generated-password>';
GRANT CONNECT ON DATABASE app TO cloudthinker_ro;
GRANT USAGE ON SCHEMA public TO cloudthinker_ro;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO cloudthinker_ro;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT ON TABLES TO cloudthinker_ro;
GRANT pg_read_all_stats TO cloudthinker_ro;
ALTER ROLE cloudthinker_ro SET default_transaction_read_only = on;

pg_read_all_stats lets the user read pg_stat_statements and other statistics views without being a superuser.

2. Allow CloudThinker's egress IPs. The authorize-security-group-ingress call above, one rule per egress IP, on port 5432 only.

3. Run the connection test, and read a failure by what it rules out. The test checks four things in order, and each failure points somewhere different:

  • Reachability fails. The credential was never tried. The problem is the path: the database isn't reachable from the internet, or its security group doesn't allow CloudThinker's egress IPs on 5432.
  • Authentication fails. The path works and the database answered. Check the password, and check pg_hba.conf rules if you're not on RDS.
  • Authorization fails. The user logged in but can't read what the skill needs, usually a missing USAGE on a schema other than public.
  • Scope validation fails. The permissions don't match what the skill expects. Check for grants inherited from another role, which can make a "read-only" user broader than you meant, and tighten them before any skill uses the connection.

When something fails, CloudThinker tells you which check failed and how to fix it.

4. Use it. From chat:

"Using the production Postgres connection, show the ten slowest queries by total time from pg_stat_statements and explain what's driving the top three. Read only, change nothing."


Getting connected in four steps

Setting up a connection takes minutes, not days. The process is the same for every integration.

01Select

Service

Pick from 99 built-in connections or any MCP server.

02Create

Credentials

Follow the scoped instructions for that service.

03Validate

Four checks

Reachability, authentication, authorization and scope.

04Use

Ready

Available across your workspace, and to custom agents it’s attached to.

Setup is the same for every integration.

Step 1: Select a service

Choose from 99 built-in connections, plus any tool with an MCP server, across cloud providers, databases, infrastructure tools, observability platforms and collaboration tools:

CategoryIntegrations
Cloud ProvidersAWS, Google Cloud, Azure
DatabasesPostgreSQL, MySQL, Elasticsearch
InfrastructureKubernetes (EKS, GKE, AKS), Cloudflare
ObservabilityGrafana, Datadog, Prometheus
CollaborationSlack, Jira, Confluence, PagerDuty
Source ControlGitHub, GitLab, Bitbucket
CustomAny MCP-compatible server

Step 2: Create credentials

CloudThinker gives step-by-step instructions for creating properly scoped credentials for each service. For AWS, that's an IAM role with a specific trust policy. For Kubernetes, a service account with RBAC bindings. For databases, a read-only user with grants on target schemas.

We tell you exactly what to create and why. No guessing, no over-provisioning.

Step 3: Connect and validate

Enter your credentials in CloudThinker and run the built-in connection test. It verifies:

  • Network reachability (can we reach your endpoint?)
  • Authentication (are the credentials valid?)
  • Authorization (do we have the expected permissions?)
  • Scope validation (are permissions correctly scoped?)

If anything fails, CloudThinker tells you exactly what went wrong and how to fix it.

Step 4: Ready to use

Once connected, skills that target that system can use it. The connection is available across your workspace: the built-in CloudThinker agent can use it, and a custom agent uses it only if it's attached. No additional configuration is needed.


MCP: extend beyond built-in connections

For tools and services not covered by the 99 built-in connections, the Model Context Protocol (MCP) provides a standard way to add custom integrations.

An MCP server is a bridge between CloudThinker and any API, database or service. You define the tools, inputs and outputs. The server must speak Streamable HTTP or SSE and be reachable from the internet. CloudThinker sorts each tool into a read or a write, and writes go through Auto Mode.

So CloudThinker isn't limited to the integrations we've built. Internal tools, custom APIs and niche platforms get the same security guarantees as built-in connections.


Choosing the right network option

PublicAllowlist IPEnvironmentDedicated or self-hosted
Network pathPublic internetPublic internet (IP-gated)Outbound HTTPS from your networkInside your own cloud
Setup complexityLowLowMediumHigh
Inbound exposureYesYes (restricted)NoneNone
Best forSaaS APIs, dev/stagingDatabases with IP rulesPrivate services, internal toolsOn-premise, hybrid, regulated
AvailabilityGenerally availableGenerally availableBetaEarly access

Most teams start with Public or Allowlist IP, and run an environment for services that must stay private. Dedicated and self-hosted deployments suit teams that need the whole platform inside their own boundary.

You can mix options in the same workspace: Public for your Datadog integration, an allowlist for a database with IP rules, and an environment next to your on-premise data warehouse.


Why this beats the usual integration patterns

Typical integrationCloudThinker Connections
Network pathDictated by the vendorChosen by you, per connection
Private resourcesOpened up or reached by a host agentAn environment that dials out, or self-hosted
Credential scopeBroad, so it works everywhereLeast privilege, read-only to start
Credential handlingLong-lived in a config fileEncrypted, injected only when a command runs
WritesWhatever the key allowsThrough Auto Mode, audited
EvidenceVendor logs, if you askAudit Logs nobody can edit, CSV export

The deeper difference is who sets the terms. A typical integration arrives with its access requirements and your network adapts. Connections adapts to your network instead: you choose the path, you write the credential, and every use of it is on the record.


What's next

Connections is the foundation the rest of CloudThinker's platform stands on. Without secure, reliable access to your infrastructure, AI agents can only guess.

With Connections, CloudThinker can:

  • Monitor your infrastructure in real time through Grafana and Datadog
  • Analyze your databases with read-only query access
  • Investigate incidents by correlating data across your whole stack
  • Optimize cloud spend by reading cost and usage data directly
  • Review code by connecting to GitHub or GitLab repositories

A good first prompt once your first connection is green:

"List what you can reach through my connections, and for each one tell me whether the credential is read-only and which network path it uses."


Related reading

Ready to connect your infrastructure?

About the author

ST

Steve Tran

Founder & CTO, CloudThinker

Steve Tran is the founder and CTO of CloudThinker, which builds Frontier Investigation Agents for production cloud operations. He writes about incident investigation, cloud cost, and the practices teams use to safely run autonomous AI agents against production AWS, GCP, and Azure environments.

connectionsnetworkingsecurityvpcendpointvpnenterpriseintegrations