Introducing AI agents in Port

April 28, 2025

Ready to start?

Introducing AI agents in Port

In the past year, we’ve been amazed to see AI evolve from simple chatbots and file-based LLMs to fully-fledged agentic assistants that can build entire applications from scratch. We’re thrilled to join this evolution with our first native AI agents in Port, which are now available in closed beta.

With native AI capabilities in Port, we are making your internal developer portal (IDP) even more powerful and more intuitive. We are extending the role of the IDP beyond serving your teams as a single source of truth for engineering metadata, to now become a unified hub for running AI agents safely, and enabling developers to easily get answers about your systems, service health, ownership, and more. 

See some example agents in our public demo and try it out for yourself. Read on to learn what we’re building, and join the beta here.

{{cta-demo-baner}}

Enter Port AI agents

With this launch, we’re providing some built-in AI agents that provide immediate and practical value. But these agents are just a starting point — what we’re really enabling is the ability to create your own AI agents in Port, to fit the needs of your engineering teams.

AI agents in Port integrate natively with your unique data model and our portal pillar building blocks, allowing you to create advanced automation workflows to boost your developers' productivity and help make the developer experience even better. We believe that including AI tools and agents in your internal developer portal — and accommodating them as teams would any other software tool — is an important step toward empowering software engineers. 

The first and most popular agents we’re introducing are the task manager and the incident manager. Each can answer day-to-day questions like:

  • Who is on call for the payments service?
  • Which tasks should I attend to first? 
  • What are my team’s open PRs to review?
  • Which services don’t meet our Gold standard for production readiness?

They can also be tasked with running specific self-service actions from Port, allowing you to even give them tasks like “please acknowledge this incident for me,” or “nudge the reviewers of all my PRs that have been open for more than 2 days.”

Using Port's AI task manager agent

But you can also seamlessly integrate AI agents into workflow automation. One example we are sharing is one we named Clarity AI — whenever someone starts work on a Jira task, Port adds a comment with all the required context like the service, APIs, owners, and past tasks in this area for reference, etc., making it easier to get started right away.

Integrate AI into your workflow automations in Port

Why Port is the best hub for engineering AI agents

Until recently, most AI tools have relied primarily on their local knowledge with some additional files they can index and reference. But to effectively write code that meets all the requirements of a business, AI coding assistants need to be aware of their organization’s rules, ownership structures, previous tasks in the area, the importance of APIs, and more. To properly review code, AI needs to understand the standards, requirements, goals, and the priority of pull requests. Ultimately, AI agents in Port and AI in other engineering tools will only be successful if they are able to navigate your unique SDLC and work within your unique organizational context.

Port's core strength is its flexible data model, which imports and integrates your entire engineering ecosystem into one place, and reflects that data in a way that speaks your organization's language. Your data exists in the real-time context of your SDLC, with clear ownership relations and business context — which is in stark contrast to AI tools that only have the context of the code open at the time in the IDE, or that connect to third parties and try to make sense of the noise.

This is the primary reason Port provides the model that's best suited for working with AI tools in engineering. Port blueprints are built exactly for that. The underlying data model describes your organization's structure, tools, terminology, relationships, and ownerships, and the interface designer graphically represents these relationships in visualizations. Building AI agents inside Port gives us the benefits of both worlds: a structured and flexible data model that reflects your source of truth, and the dynamic creative AI that transforms on top of that.

A perfect example that demonstrates this is Port’s team view, which shows all recent issues, related pull requests, recent builds, service owners, and releases all in one place.

The Plan My Day view in Port, with an AI agent installed

AI is here, but so are the challenges

Engineers and developers are, to date, one of the primary user groups for AI and LLMs. AI agents stand to empower developers even further—potentially to the point of replacing human developers themselves through autonomous coding agents. AI agents in particular have massive potential to change our lives, our workforce, and open opportunities that were not possible before.

Though GenAI can accelerate specific tasks like coding or debugging, it also introduces new complexities in integration, governance, and operations. According to the 2024 State of DORA Report, 75% of respondents rely on AI for coding tasks, but it often comes with a price of reduced performance and is still gaining users' trust.

To realize the full potential of AI, engineering teams will first need to control their AI agents and deploy them with precision. Most organizations realize they will need strict privacy and security standards for AI, as they would with any new technology. But the challenges compound for platform engineering teams, who find themselves tasked with proving their return on investment in AI tools, how to measure its productivity, how to choose the AI tools their companies use, and how to govern them productively, while keeping the company's best interests in mind. 

Port’s AI agents are designed with security as a priority and the Port data model is a key enabler for this functionality as well. Your AI agents only have access to the data you explicitly provide when you design them — but the agents also inherit the end user’s role-based access control permissions and can only respond with data that user is allowed to access. 

Edit your AI agent the same way you edit self-service actions in Port

Stay tuned for more on Port native AI

Coming into 2025, our vision is not just to use AI but to make AI agents first-class citizens integrated within the developer portal. We embarked on this journey because we see a critical need for a central platform that provides the context, governance, and orchestration required to make AI truly effective and safe for engineering organizations.

These native AI capabilities are just the beginning — we are already experimenting with connecting our MCP server to popular AI tools like Cursor, improving the AI agents' analytical abilities, and, down the line, looking into agent-to-agent collaboration with engineering tools like GitHub Copilot. We are just getting started!

If you’re a current Port customer, you can apply to join the beta here. If you’re not a Port customer, you can see examples like an incident management agent or an agent that helps you plan your daily priorities in our public demo. 

Want to be the first to hear more? Subscribe to our newsletter to be the first to learn about product updates, new Port Experiences, and more.

{{survey}}

Download your survey template today

By clicking this button, you agree to our Terms of Use and Privacy Policy
{{roadmap}}

Free Roadmap planner for Platform Engineering teams

  • Set Clear Goals for Your Portal

  • Define Features and Milestones

  • Stay Aligned and Keep Moving Forward

{{rfp}}

Free RFP template for Internal Developer Portal

Creating an RFP for an internal developer portal doesn’t have to be complex. Our template gives you a streamlined path to start strong and ensure you’re covering all the key details.

{{ai_jq}}

Leverage AI to generate optimized JQ commands

test them in real-time, and refine your approach instantly. This powerful tool lets you experiment, troubleshoot, and fine-tune your queries—taking your development workflow to the next level.

{{cta_1}}

Check out Port's pre-populated demo and see what it's all about.

Check live demo

No email required

{{cta_survey}}

Check out the 2025 State of Internal Developer Portals report

See the full report

No email required

{{cta_2}}

Contact sales for a technical product walkthrough

Let’s start
{{cta_3}}

Open a free Port account. No credit card required

Let’s start
{{cta_4}}

Watch Port live coding videos - setting up an internal developer portal & platform

{{cta_5}}

Check out Port's pre-populated demo and see what it's all about.

(no email required)

Let’s start
{{cta_6}}

Contact sales for a technical walkthrough of Port

Let’s start
{{cta_7}}

Open a free Port account. No credit card required

Let’s start
{{cta_8}}

Watch Port live coding videos - setting up an internal developer portal & platform

{{cta-demo}}
{{reading-box-backstage-vs-port}}
{{cta-backstage-docs-button}}

Example JSON block

{
  "foo": "bar"
}

Order Domain

{
  "properties": {},
  "relations": {},
  "title": "Orders",
  "identifier": "Orders"
}

Cart System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Cart",
  "title": "Cart"
}

Products System

{
  "properties": {},
  "relations": {
    "domain": "Orders"
  },
  "identifier": "Products",
  "title": "Products"
}

Cart Resource

{
  "properties": {
    "type": "postgress"
  },
  "relations": {},
  "icon": "GPU",
  "title": "Cart SQL database",
  "identifier": "cart-sql-sb"
}

Cart API

{
 "identifier": "CartAPI",
 "title": "Cart API",
 "blueprint": "API",
 "properties": {
   "type": "Open API"
 },
 "relations": {
   "provider": "CartService"
 },
 "icon": "Link"
}

Core Kafka Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Kafka Library",
  "identifier": "CoreKafkaLibrary"
}

Core Payment Library

{
  "properties": {
    "type": "library"
  },
  "relations": {
    "system": "Cart"
  },
  "title": "Core Payment Library",
  "identifier": "CorePaymentLibrary"
}

Cart Service JSON

{
 "identifier": "CartService",
 "title": "Cart Service",
 "blueprint": "Component",
 "properties": {
   "type": "service"
 },
 "relations": {
   "system": "Cart",
   "resources": [
     "cart-sql-sb"
   ],
   "consumesApi": [],
   "components": [
     "CorePaymentLibrary",
     "CoreKafkaLibrary"
   ]
 },
 "icon": "Cloud"
}

Products Service JSON

{
  "identifier": "ProductsService",
  "title": "Products Service",
  "blueprint": "Component",
  "properties": {
    "type": "service"
  },
  "relations": {
    "system": "Products",
    "consumesApi": [
      "CartAPI"
    ],
    "components": []
  }
}

Component Blueprint

{
 "identifier": "Component",
 "title": "Component",
 "icon": "Cloud",
 "schema": {
   "properties": {
     "type": {
       "enum": [
         "service",
         "library"
       ],
       "icon": "Docs",
       "type": "string",
       "enumColors": {
         "service": "blue",
         "library": "green"
       }
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "system": {
     "target": "System",
     "required": false,
     "many": false
   },
   "resources": {
     "target": "Resource",
     "required": false,
     "many": true
   },
   "consumesApi": {
     "target": "API",
     "required": false,
     "many": true
   },
   "components": {
     "target": "Component",
     "required": false,
     "many": true
   },
   "providesApi": {
     "target": "API",
     "required": false,
     "many": false
   }
 }
}

Resource Blueprint

{
 “identifier”: “Resource”,
 “title”: “Resource”,
 “icon”: “DevopsTool”,
 “schema”: {
   “properties”: {
     “type”: {
       “enum”: [
         “postgress”,
         “kafka-topic”,
         “rabbit-queue”,
         “s3-bucket”
       ],
       “icon”: “Docs”,
       “type”: “string”
     }
   },
   “required”: []
 },
 “mirrorProperties”: {},
 “formulaProperties”: {},
 “calculationProperties”: {},
 “relations”: {}
}

API Blueprint

{
 "identifier": "API",
 "title": "API",
 "icon": "Link",
 "schema": {
   "properties": {
     "type": {
       "type": "string",
       "enum": [
         "Open API",
         "grpc"
       ]
     }
   },
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "provider": {
     "target": "Component",
     "required": true,
     "many": false
   }
 }
}

Domain Blueprint

{
 "identifier": "Domain",
 "title": "Domain",
 "icon": "Server",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {}
}

System Blueprint

{
 "identifier": "System",
 "title": "System",
 "icon": "DevopsTool",
 "schema": {
   "properties": {},
   "required": []
 },
 "mirrorProperties": {},
 "formulaProperties": {},
 "calculationProperties": {},
 "relations": {
   "domain": {
     "target": "Domain",
     "required": true,
     "many": false
   }
 }
}
{{tabel-1}}

Microservices SDLC

  • Scaffold a new microservice

  • Deploy (canary or blue-green)

  • Feature flagging

  • Revert

  • Lock deployments

  • Add Secret

  • Force merge pull request (skip tests on crises)

  • Add environment variable to service

  • Add IaC to the service

  • Upgrade package version

Development environments

  • Spin up a developer environment for 5 days

  • ETL mock data to environment

  • Invite developer to the environment

  • Extend TTL by 3 days

Cloud resources

  • Provision a cloud resource

  • Modify a cloud resource

  • Get permissions to access cloud resource

SRE actions

  • Update pod count

  • Update auto-scaling group

  • Execute incident response runbook automation

Data Engineering

  • Add / Remove / Update Column to table

  • Run Airflow DAG

  • Duplicate table

Backoffice

  • Change customer configuration

  • Update customer software version

  • Upgrade - Downgrade plan tier

  • Create - Delete customer

Machine learning actions

  • Train model

  • Pre-process dataset

  • Deploy

  • A/B testing traffic route

  • Revert

  • Spin up remote Jupyter notebook

{{tabel-2}}

Engineering tools

  • Observability

  • Tasks management

  • CI/CD

  • On-Call management

  • Troubleshooting tools

  • DevSecOps

  • Runbooks

Infrastructure

  • Cloud Resources

  • K8S

  • Containers & Serverless

  • IaC

  • Databases

  • Environments

  • Regions

Software and more

  • Microservices

  • Docker Images

  • Docs

  • APIs

  • 3rd parties

  • Runbooks

  • Cron jobs

Starting with Port is simple, fast and free.

Let’s start