You’ve turned on credit pooling, or you’re about to, and now the decisions are yours: how many seats to keep, how many additional credits to buy, and what limit each developer gets. Set limits too tight and developers get blocked in the middle of a task. Set them too loose and one runaway automation job can drain the pool and pause Kiro for everyone. The data to make these calls is already in your AWS account, in your Kiro user activity reports. This post shows you how to read it.

The launch post, Share Kiro credits across your team with credit pooling, published November 4, 2026, introduced credit pooling: a shared pool of Kiro credits that every user in the pool draws from. Credits one developer doesn’t need automatically become available to a teammate who does.

Credit pooling is for organizations. It works with Kiro profiles that use AWS IAM Identity Center, Okta, or Microsoft Entra ID. Individual Kiro subscriptions, such as a personal account with a social login, can’t share credits through a pool, and credit pooling isn’t available in AWS GovCloud (US).

This post is a hands-on guide for admins. It describes how the credit pool behaves day to day and how to size it and dial in your limit settings from your own usage data. It also covers the best practices that keep it running smoothly.

How credit pooling works

In credit pooling, a seat is one user’s access to the pool, and each seat adds 500 monthly credits. When someone leaves, removing them frees their seat for someone else. For details, see Manage seats.

The following diagram shows how each seat’s 500 monthly credit inclusion flows into one shared pool, together with any additional credits you buy, and how every user draws from that pool. It also compares pooling with per-user credits.

How credit pooling works: each seat adds 500 monthly credits to one shared credit pool, additional credits can be bought at any time and are good for 12 months, and every user draws from the pool. Before pooling, each user’s credits are set by their subscription tier and credits a user doesn’t need go unused. With pooling, heavy users draw on credits light users don’t need before you buy anything extra.

Figure 1: How each seat’s 500 monthly credits flow into one shared pool that every user draws from, compared with per-user credits

Here’s a short summary of the core mechanics and how they play out once your pool is running. Each billing cycle, every $20 seat adds 500 credits to the pool, so 100 seats add 50,000. Every seated user draws from the pool, including users that run Kiro in headless mode, such as continuous integration and continuous delivery (CI/CD) pipelines. These credits continue to reset at the end of each billing cycle, but now they’re available for anyone in the pool to use.

When the pool runs out

Admins can buy additional credits at any time in the Kiro console. Additional credits roll over and are good for 12 months after purchase.

Which credits are used first

Monthly credits are used first because they reset at the end of each billing cycle. After the monthly credits run out, Kiro draws from additional credits, starting with the oldest purchase.

Where the savings come from

Credit pooling can help you save in three ways:

  • Shared credits absorb uneven usage. Your heaviest users draw on credits teammates don’t need before you buy anything extra.
  • Seats follow your team. Add seats as people join, and remove a user to release their seat when they leave.
  • Additional credits only when you need them. Buy them at any time, and they roll over for 12 months.

Walkthrough

Today, all you have is a daily report of each user’s consumption. This walkthrough turns that report into a plan in four steps. Step 1 loads the reports into Amazon Athena. Step 2 shows how each month used the pool. Step 3 recommends a seat count and a buffer of additional credits. Step 4 suggests a limit for each user.

Prerequisites

Before you start, confirm that the following are in place.

  • User activity reports turned on for your Kiro profile. The analysis in this post is based on the daily user activity CSV reports that Kiro writes to an Amazon Simple Storage Service (Amazon S3) bucket. To set them up, including the bucket policy Kiro needs to write to the bucket, see Turn on the CSV report.
  • Access to Amazon Athena, with permission to read the report location and write query results. For example, attach the AWS managed policy AmazonAthenaFullAccess, and allow s3:GetObject and s3:ListBucket on your report bucket.
  • The number of seats you bought for a prepaid pool, or the number of users in a postpaid pool. You manage seats under Access management > Credit sharing in the Kiro console. The activity report can’t give you this number.
  • An administrator role with the credit pooling permissions, so you can change seats, limits, and additional credits after the analysis.

Right-size your pool from your usage data

Your per-user activity reports record each user’s consumption.

Where to start depends on whether you already have data. If your team already uses Kiro, the activity report has recorded every user’s consumption all along, and the following queries run on that history as-is. Run Steps 2 and 3 now, before you pick a seat count. Step 3 tells you what that count needs to be.

If you are new to Kiro, there is nothing to analyze. Buy one seat for each person who needs access. That is the license, and the pool follows from it at 500 credits per seat. Keep a small buffer of additional credits (best practice 4), and start with generous limits (best practice 2). Either way, run one full billing cycle on pooling and come back to Step 2.

Step 1: Create the table and view

In the LOCATION line, replace the four capitalized placeholders. Use the Amazon S3 location you chose when you turned on the CSV report.

  • YOUR-BUCKET: the bucket name from your Amazon S3 location, for example amzn-s3-demo-bucket.
  • YOUR-PREFIX: the folder after the bucket name, for example user-activity-reports.
  • ACCOUNT-ID: the 12-digit AWS account where your users are subscribed.
  • REGION: the Region where you installed your Kiro profile, for example the US East (N. Virginia) Region (us-east-1).

For example, if your S3 location is s3://amzn-s3-demo-bucket/user-activity-reports/, the LOCATION line becomes s3://amzn-s3-demo-bucket/user-activity-reports/AWSLogs/111122223333/KiroLogs/user_report/us-east-1/. Keep the AWSLogs/.../KiroLogs/user_report/ part exactly as written. Kiro creates those folders itself.

CREATE EXTERNAL TABLE kiro_user_activity_raw ( c1 STRING, c2 STRING, c3 STRING, c4 STRING, c5 STRING, c6 STRING, c7 STRING, c8 STRING, c9 STRING, c10 STRING, c11 STRING, c12 STRING, c13 STRING, c14 STRING, c15 STRING, c16 STRING, c17 STRING, c18 STRING, c19 STRING, c20 STRING ) ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde' WITH SERDEPROPERTIES ('separatorChar' = ',', 'quoteChar' = '"') LOCATION 's3://YOUR-BUCKET/YOUR-PREFIX/AWSLogs/ACCOUNT-ID/KiroLogs/user_report/REGION/';

Then create the view that the queries in the next steps read from:

CREATE OR REPLACE VIEW kiro_user_activity AS WITH headers AS ( -- The first row of each report file names its columns. SELECT "$path" AS report_file, ARRAY[c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20] AS names FROM kiro_user_activity_raw WHERE c1 = 'Date' ), report_rows AS ( SELECT "$path" AS report_file, ARRAY[c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20] AS vals FROM kiro_user_activity_raw WHERE c1 <> 'Date' ) -- Pick each value by its column name in that file's header. -- A column the file doesn't have comes back NULL. SELECT TRY(vals[array_position(names, 'Date')]) AS report_date, TRY(vals[array_position(names, 'UserId')]) AS user_id, TRY(vals[array_position(names, 'Client_Type')]) AS client_type, TRY(vals[array_position(names, 'Credits_Used')]) AS credits_used, TRY(vals[array_position(names, 'User_Email')]) AS user_email, TRY(vals[array_position(names, 'Usage_Limit')]) AS usage_limit, TRY(vals[array_position(names, 'Subscription_Tier')]) AS subscription_tier FROM report_rows JOIN headers USING (report_file);

Three details in that setup are worth knowing:

  • OpenCSVSerde, not ROW FORMAT DELIMITED. Kiro quotes some fields, and the simpler row format leaves the quote marks on, which breaks any join on user id.
  • The view finds columns by name, not position. Kiro has added columns to the report over time, so a position can hold a different column in an older file. The view reads each file’s header row and picks values by name. A column a file doesn’t have, like usage_limit in older reports, comes back empty.
  • The table reads the first 20 columns, all as text. They must be text, because the first row of each file holds column names. Everything the queries use is within the first 14 columns, and anything past 20 is ignored. If a column the queries need ever moves past 20, add c21 and up to both the table and the view.

Confirm it worked before going further:

SELECT COUNT(DISTINCT user_id) AS users, ROUND(SUM(CAST(credits_used AS DOUBLE)), 2) AS credits, MIN(report_date) AS first_day, MAX(report_date) AS last_day FROM kiro_user_activity;

For an example 100-seat team with six months of reports, that returns:

users | credits | first_day | last_day -------+-----------+------------+------------ 90 | 245990.46 | 2026-05-01 | 2026-10-23

If that returns zero users, the LOCATION prefix is wrong. If user_id values come back wrapped in quote marks, the table was created with ROW FORMAT DELIMITED.

Step 2: Re-run every cycle and let the data correct your estimate

This is the query you come back to each cycle. It returns one row per closed month at today’s seat count, so one run shows your whole history. Change only the seat count. It answers the right-sizing question directly: at the seats I pay for now, which months overflow the pool, and how much sat unused?

WITH -- ========================= EDIT ME ========================= inputs AS ( SELECT 100 AS seats -- the seats you pay for today, from the console ), -- ======================= END EDIT ME ======================= -- Closed months only: the current month is not a full billing cycle yet. per_user_month AS ( SELECT substr(a.report_date, 1, 7) AS month, a.user_id, SUM(CAST(a.credits_used AS DOUBLE)) AS credits FROM kiro_user_activity a WHERE date(a.report_date) < date_trunc('month', current_date) GROUP BY substr(a.report_date, 1, 7), a.user_id ), totals AS ( SELECT month, COUNT(*) AS active_users, SUM(credits) AS consumed, SUM(GREATEST(credits - 500.0, 0)) AS beyond_own_seat, approx_percentile(credits, 0.50) AS p50, approx_percentile(credits, 0.90) AS p90, MAX(credits) AS max_user FROM per_user_month GROUP BY month ) SELECT t.month, i.seats, t.active_users, GREATEST(i.seats - t.active_users, 0) AS seats_never_used, ROUND(t.consumed, 0) AS credits_consumed, ROUND(GREATEST(i.seats * 500.0 - t.consumed, 0), 0) AS pool_credits_unused, ROUND(GREATEST(i.seats * 500.0 - t.consumed, 0) * 0.04, 2) AS unused_credit_value_usd, ROUND(t.beyond_own_seat - GREATEST(t.consumed - i.seats * 500.0, 0), 0) AS credits_covered_by_sharing, ROUND(GREATEST(t.consumed - i.seats * 500.0, 0), 0) AS additional_credits_needed, ROUND(i.seats * 20.0 + GREATEST(t.consumed - i.seats * 500.0, 0) * 0.04, 2) AS estimated_monthly_cost, ROUND(t.active_users * 20.0 + GREATEST(t.consumed - t.active_users * 500.0, 0) * 0.04, 2) AS cost_if_never_used_seats_reclaimed, ROUND(t.p90, 0) AS p90_credits_per_user, ROUND(t.max_user, 0) AS max_credits_per_user FROM totals t CROSS JOIN inputs i ORDER BY t.month;

Sample output for the same team, one column per closed month. The current month is left out because it isn’t a full cycle:

month | 2026-05 | 2026-06 | 2026-07 | 2026-08 | 2026-09 ------------------------------------+---------+---------+---------+---------+--------- seats | 100 | 100 | 100 | 100 | 100 active_users | 85 | 89 | 83 | 79 | 83 seats_never_used | 15 | 11 | 17 | 21 | 17 credits_consumed | 41863.0 | 44528.0 | 48003.0 | 38274.0 | 41943.0 pool_credits_unused | 8137.0 | 5472.0 | 1997.0 | 11726.0 | 8057.0 unused_credit_value_usd | 325.49 | 218.86 | 79.9 | 469.05 | 322.26 credits_covered_by_sharing | 10225.0 | 11214.0 | 13816.0 | 7654.0 | 9687.0 additional_credits_needed | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 estimated_monthly_cost | 2000.0 | 2000.0 | 2000.0 | 2000.0 | 2000.0 cost_if_never_used_seats_reclaimed | 1700.0 | 1781.14 | 1920.1 | 1580.0 | 1677.74 p90_credits_per_user | 897.0 | 932.0 | 761.0 | 762.0 | 749.0 max_credits_per_user | 2022.0 | 2601.0 | 2368.0 | 1748.0 | 2768.0

For this team, credits that light users didn’t need covered 7,654 to 13,816 credits of heavier users’ demand every month, so it never bought additional credits. That’s how pooling can work. Even so, 2,000 to 11,700 credits went unused each month and 11 to 21 seats sat idle, which Step 3 turns into a plan.

Read it across, not down. If pool_credits_unused stays large for a couple of cycles, the seats behind it are not a one-off. Reclaim them from people who no longer need access and re-run next month to confirm.

If additional_credits_needed is climbing, buy additional credits earlier in the cycle rather than adding seats (see best practice 7). credits_covered_by_sharing, multiplied by $0.04, estimates what sharing saved you each month. When p90_credits_per_user and max_credits_per_user settle into a stable range, that is your signal to set limits with headroom above them.

seats_never_used counts seats with no activity that month, and cost_if_never_used_seats_reclaimed is your cost if you reclaimed them all. Treat it as a bound, not a target. Step 3 looks across several months before it recommends cuts.

The percentiles are your starting point for limits. p90_credits_per_user reflects your heavy users, and max_credits_per_user is the person who reaches a limit first. With fewer than a few dozen active users, lean on max. Step 4 suggests a limit for each person.

Step 3: Turn the numbers into a resizing plan

Step 2 shows what happened. This query turns that into a plan: seats to keep and reclaim, additional credits to hold, and what the change saves. In the EDIT ME block, set your seat count and how many closed months to look back over. Three months is a sensible default, because one quiet month doesn’t mean a seat is unneeded.

WITH -- ========================= EDIT ME ========================= inputs AS ( SELECT 100 AS seats, -- the seats you pay for today, from the console 3 AS lookback_months -- closed months to base the plan on ), -- ======================= END EDIT ME ======================= bounds AS ( SELECT i.seats, date_trunc('month', current_date) AS this_month, date_add('month', -i.lookback_months, date_trunc('month', current_date)) AS since FROM inputs i ), -- Everyone who used Kiro since the window started, this month included, -- needs a seat. Seats nobody used in that time are the ones to reclaim. users AS ( SELECT COUNT(DISTINCT a.user_id) AS active_users FROM kiro_user_activity a CROSS JOIN bounds b WHERE date(a.report_date) >= b.since ), -- Credits consumed in each closed month of the window. months AS ( SELECT substr(a.report_date, 1, 7) AS month, SUM(CAST(a.credits_used AS DOUBLE)) AS consumed FROM kiro_user_activity a CROSS JOIN bounds b WHERE date(a.report_date) >= b.since AND date(a.report_date) < b.this_month GROUP BY substr(a.report_date, 1, 7) ), -- Never recommend more seats than you have, so every result stays sensible. sized AS ( SELECT b.seats, u.active_users, LEAST(b.seats, u.active_users) AS rec FROM bounds b CROSS JOIN users u ), -- Each window month at today's seats and at the recommended seats, with -- anything past the pool bought as additional credits. plan AS ( SELECT s.seats, s.active_users, s.rec, MAX(m.consumed) AS busiest, AVG(s.seats * 20.0 + GREATEST(m.consumed - s.seats * 500.0, 0) * 0.04) AS cost_now, AVG(s.rec * 20.0 + GREATEST(m.consumed - s.rec * 500.0, 0) * 0.04) AS cost_resized FROM sized s CROSS JOIN months m GROUP BY s.seats, s.active_users, s.rec ) SELECT seats, active_users AS active_users_in_window, rec AS recommended_seats, seats - rec AS seats_to_reclaim, ROUND(busiest, 0) AS busiest_month_credits, rec * 500 AS recommended_pool_credits, ROUND(GREATEST(busiest - rec * 500.0, 0), 0) AS additional_credits_to_keep, ROUND(cost_now, 2) AS avg_monthly_cost_now, ROUND(cost_resized, 2) AS avg_monthly_cost_resized, ROUND(cost_now - cost_resized, 2) AS avg_monthly_savings FROM plan;

Sample output for the same team at 100 seats, looking back over July through September:

seats | 100 active_users_in_window | 86 recommended_seats | 86 seats_to_reclaim | 14 busiest_month_credits | 48003.0 recommended_pool_credits | 43000 additional_credits_to_keep | 5003.0 avg_monthly_cost_now | 2000.0 avg_monthly_cost_resized | 1786.7 avg_monthly_savings | 213.3

recommended_seats is one seat for everyone who used Kiro in the lookback or so far this month, however lightly, and seats_to_reclaim is the rest. The report can’t tell you who joined last week or is on leave, so check the names in the Kiro console before you reclaim anything.

additional_credits_to_keep is how far your busiest month ran past the recommended pool. Keep at least that many additional credits on hand going into each cycle (best practice 4). That’s a balance to hold, not an amount to buy every month, so check what’s already in your pool on the Kiro dashboard and buy only the difference. If Step 2 shows consumption climbing, keep more than this.

The cost columns compare the lookback months at your current seats with their cost at the recommended seats, averaged per month. Each month costs $20 per seat plus $0.04 per credit used beyond the pool, counted in the month it’s used. For this example team, reclaiming 14 idle seats would save about $213.30 a month on average, roughly $2,600 a year if the pattern holds. In July, the busiest month, about $200 of the $280 in seat savings came back as additional credits, which is why the buffer matters.

Step 4: Find users whose limits need to change

Seats and the pool are half of right-sizing. Per-user limits are the other half. This query lists the people whose limit is out of step with what they use. It flags anyone whose busiest month in the lookback reached 80% of their limit, anyone who stayed under 25% of their limit every month, and anyone with no limit set. For each one it suggests a new limit: their busiest month plus 25%, rounded up to the nearest 100 and never below the 500 credits a seat adds to the pool. It only lowers limits for people active in every month of the lookback, so a new joiner isn’t cut after one quiet month. Adjust the thresholds in the EDIT ME block.

WITH -- ========================= EDIT ME ========================= inputs AS ( SELECT 3 AS lookback_months, -- closed months to look back over 0.80 AS raise_at, -- raise if the busiest month reached 80% of the limit 0.25 AS lower_below, -- lower if every month stayed under 25% of the limit 1.25 AS headroom -- new limit = busiest month plus 25% ), -- ======================= END EDIT ME ======================= bounds AS ( SELECT date_add('month', -i.lookback_months, date_trunc('month', current_date)) AS since FROM inputs i ), -- Credits per user in each month of the window, this month so far included, -- so a suggested limit is never below what someone has already used. per_user_month AS ( SELECT a.user_id, substr(a.report_date, 1, 7) AS month, ROUND(SUM(CAST(a.credits_used AS DOUBLE)), 2) AS credits FROM kiro_user_activity a CROSS JOIN bounds b WHERE date(a.report_date) >= b.since GROUP BY a.user_id, substr(a.report_date, 1, 7) ), -- Each user's plan, limit and email from their most recent report. On a pool, -- Usage_Limit is the pool limit (999999 means none is set). On a subscription -- (Pro, Pro+, Pro Max, Power), it's the tier's monthly credit allowance. -- If one day has both, the pool row wins. Older reports have no limit -- column, so the view returns NULL and they're skipped. latest AS ( SELECT a.user_id, max_by(a.user_email, a.report_date || IF(upper(a.subscription_tier) = 'POOLING', '1', '0')) AS user_email, max_by(replace(upper(a.subscription_tier), '_', ''), a.report_date || IF(upper(a.subscription_tier) = 'POOLING', '1', '0')) AS plan, max_by(TRY_CAST(a.usage_limit AS DOUBLE), a.report_date || IF(upper(a.subscription_tier) = 'POOLING', '1', '0')) AS lim FROM kiro_user_activity a CROSS JOIN bounds b WHERE date(a.report_date) >= b.since AND a.usage_limit IS NOT NULL AND COALESCE(a.subscription_tier, '') <> '' GROUP BY a.user_id ), -- Suggested limit: the busiest month plus headroom, rounded up to the -- nearest 100, and never below the 500 credits one seat brings to the pool. -- months_active counts the closed months in the lookback with any use. scored AS ( SELECT l.user_email, l.plan, COALESCE(l.lim, 999999) AS lim, MAX(m.credits) AS busiest, COUNT_IF(m.month < date_format(current_date, '%Y-%m')) AS months_active, GREATEST(ceiling(MAX(m.credits) * i.headroom / 100) * 100, 500) AS new_limit, i.lookback_months, i.raise_at, i.lower_below FROM per_user_month m JOIN latest l ON m.user_id = l.user_id CROSS JOIN inputs i GROUP BY l.user_id, l.user_email, l.plan, l.lim, i.lookback_months, i.headroom, i.raise_at, i.lower_below ), -- Lower a limit only for someone who used Kiro in every closed month of the -- lookback, so a new joiner or someone back from leave isn't cut after one -- quiet month. flagged AS ( SELECT *, CASE WHEN plan <> 'POOLING' THEN 'limit when pooled' WHEN lim >= 999999 THEN 'set limit' WHEN busiest >= raise_at * lim THEN 'raise' WHEN busiest < lower_below * lim AND new_limit < lim AND months_active = lookback_months THEN 'lower' END AS action FROM scored ) SELECT user_email, CASE plan WHEN 'POOLING' THEN 'Pool' WHEN 'PRO' THEN 'Pro' WHEN 'PROPLUS' THEN 'Pro+' WHEN 'PROMAX' THEN 'Pro Max' WHEN 'POWER' THEN 'Power' ELSE plan END AS plan, CAST(ROUND(busiest) AS BIGINT) AS busiest_month, IF(lim >= 999999, 'none', CAST(CAST(lim AS BIGINT) AS VARCHAR)) AS usage_limit, IF(lim >= 999999, NULL, ROUND(100.0 * busiest / lim, 0)) AS pct_of_limit, action, CAST(new_limit AS BIGINT) AS new_limit FROM flagged WHERE action IS NOT NULL ORDER BY CASE action WHEN 'raise' THEN 1 WHEN 'set limit' THEN 2 WHEN 'lower' THEN 3 ELSE 4 END, user_email;

Sample output for the same team, looking back over July through October so far:

user_email | plan | busiest_month | usage_limit | pct_of_limit | action | new_limit ---------------------+------+---------------+-------------+--------------+-------------------+----------- user003@example.com | Pool | 2768 | 3000 | 92.0 | raise | 3500 user021@example.com | Pool | 994 | 1000 | 99.0 | raise | 1300 user034@example.com | Pool | 913 | 1000 | 91.0 | raise | 1200 user047@example.com | Pool | 838 | 1000 | 84.0 | raise | 1100 user079@example.com | Pool | 471 | 500 | 94.0 | raise | 600 user006@example.com | Pool | 513 | 3000 | 17.0 | lower | 700 user008@example.com | Pool | 372 | 3000 | 12.0 | lower | 500 user058@example.com | Pool | 144 | 1000 | 14.0 | lower | 500 user066@example.com | Pool | 96 | 1000 | 10.0 | lower | 500 user091@example.com | Pro | 1210 | 1000 | 121.0 | limit when pooled | 1600

The raise rows are the people closest to being blocked. In their busiest month, user021 used 994 of their 1,000 credits, so one heavy week might stop them. Raising it to 1,300 gives them room. A higher limit adds no cost until the credits are used.

The lower rows are people who use a small share of their limit, like user006, whose busiest month was 513 credits against a 3,000-credit limit. Lowering a limit doesn’t save money, because a credit costs the same whoever uses it. It limits the impact of a runaway automation job, so one person is less likely to drain the pool and block everyone. new_limit is never below what the user has already used this month, so lowering it doesn’t block them right away.

The limit when pooled rows are people still on a Pro, Pro+, Pro Max, or Power subscription. Their usage_limit is the tier’s monthly allowance, so above 100% means they need more than their tier includes, like user091. new_limit is the individual limit to allocate when you add them to the pool. Their usage is already counted in Step 3’s additional_credits_to_keep, so the buffer covers them too.

If several people in one group need the same change, change the group’s limit.

For the exceptions, set new_limit as an individual limit in the Kiro console. It takes priority over group and profile limits (best practice 2). Re-run this query each cycle to catch limits that need to move again.

Best practices for making credit pooling effective

These practices build on the numbers from the walkthrough and help you keep the pool sized without blocking anyone.

1. Learn your usage pattern first

Collect several months of data before you fine-tune anything. A couple of billing cycles show you who your heavy and light users are, how usage rises and falls through a sprint, and how quickly the pool draws down. Once you can see the trend, use the preceding analysis to size the pool and set limits.

2. Use the limit hierarchy strategically

With credit pooling, you can set per-user limits at three levels:

Level Priority Use it for
Individual Highest Setting a per-user limit that applies to a specific user (for example, a user that runs automations, or someone testing heavily)
Group Medium Setting a per-user limit that applies to all members of a group
Profile Lowest Setting a default limit applicable to all users

All limits are per-user. There are no aggregate caps at the group or profile level. A group limit sets the per-user cap for everyone in that group.

Where to start: If your team already uses Kiro, start from the limits Step 4 suggests. If you are new to Kiro, start with generous group and profile limits and tighten them after your first billing cycle, only where the data shows you need to. Over-constraining on day one creates friction and support tickets.

3. Group users by usage pattern

Consider grouping users by how they consume credits rather than only by org chart. For example, put heavy users (senior developers, machine learning engineers) in a group with a higher per-user limit, and light users (managers, reviewers) in a group with a lower one.

Grouping users by usage pattern: heavy users in a group with a higher per-user limit and light users in a group with a lower per-user limit, each drawing from the shared pool

Figure 2: Grouping users by usage pattern to apply different per-user limits

If you sync groups from your identity provider: Your existing synced groups likely mirror your org chart. Create groups for credit pooling. For example, keep your synced “Engineering” group for access management, but create separate “Kiro-Heavy-Users” and “Kiro-Standard-Users” groups to apply different per-user limits. Users can belong to multiple groups, and the highest limit wins.

4. Keep a buffer of additional credits

When the pool is empty, everyone stops. Watch your pool threshold alerts and buy additional credits before the pool runs low. Because additional credits roll over for 12 months, buying early doesn’t waste them. Step 3’s additional_credits_to_keep shows how many to hold, based on your busiest month.

5. Review and adjust monthly

The Kiro dashboard gives you three views for this:

  • Daily projected consumption with run-out date predictions.
  • Credit usage breakdown (monthly compared to additional credits).
  • Users sharing credits, credits left, and additional credits at a glance.

If you exhaust the monthly pool early, buy additional credits earlier in the cycle. If credits go unused, check whether some seats are inactive (best practice 7).

6. Use notifications to stay ahead

Credit pooling includes built-in alerts that notify admins at 80% and 100% by default:

  • Pool threshold alerts: Get notified when the pool drops below configured levels.
  • User usage alerts: Know when individual users approach their limits.
  • Seat utilization alerts: Know when assigned seats near the number you bought.

Send these to the people who can act on them.

7. Right-size seats, and use credits rather than seats for headroom

A seat is an access license first and a credit contribution second. Treat them as two separate questions.

Seats with zero usage are the first place to look. You pay $20/month for a seat whether anyone signs in or not, and the seats_to_reclaim figure from Step 3 shows how many have gone unused for the whole lookback. Reclaim those from people who no longer need access.

Lightly used seats are a different matter. Don’t cut a license from someone who uses Kiro occasionally because their consumption is low. Their unused credits already go to the pool.

For headroom, buy credits rather than seats. If demand runs ahead of your pool, buy additional credits. Monthly credits reset at the end of the cycle. Additional credits last 12 months.

Things to keep in mind

  • When the pool runs out, usage stops for everyone in it. Kiro blocks further usage, whatever each user’s limit, until you add credits.
  • Mid-cycle limit changes take effect immediately. If you lower a user’s limit below their current consumption, they’re blocked right away. If you increase their limit, they can immediately resume their AI use. Plan limit changes at the start of a billing cycle when possible.
  • In a prepaid pool, seats are billed whether occupied or not. Every seat contributes credits and costs $20/month. Factor in your idle seats when calculating return on investment.

Getting started

If you have a Kiro profile with users signing in through single sign-on (SSO), you’re ready to go:

  1. In the Kiro console, go to Access management.
  2. On the Subscriptions tab, choose Switch to credit sharing.
  3. Follow the wizard to select users or groups.

Switching is irreversible: a user you move can’t go back to an individual subscription. Have each user’s Step 4 limit ready to apply once they’re in the pool.

Key details at a glance

The following table summarizes the numbers and rules covered in this post.

Item Detail
Credits per seat 500/month (shared)
Cost per seat $20/month
Additional credits $0.04 per credit, good for 12 months
Monthly credit reset End of billing cycle
Consumption order Monthly → Additional (oldest purchase first)
Limit hierarchy Individual > Group > Profile

Start sharing

Credit pooling turns unused individual capacity into a shared resource. Teams with uneven usage can get more from the same spend, and limits at every level help you stay in control.

Ready to try it? Head to the Kiro console and turn on credit sharing under Access management. For details on seats, limits, and monitoring, see Credit pooling in the Kiro documentation.

 


About the authors

Kirankumar Chandrashekar

Kirankumar Chandrashekar

Kirankumar Chandrashekar is a Generative AI Specialist Solutions Architect at AWS, focusing on Kiro. Bringing deep expertise in AWS cloud services, DevOps, modernization, and infrastructure as code, he helps customers accelerate their development cycles and elevate developer productivity through innovative AI-powered solutions. By leveraging Kiro, he enables teams to build applications faster, automate routine tasks, and streamline development workflows. Kirankumar is dedicated to enhancing developer efficiency while solving complex customer challenges, and enjoys music, cooking, and traveling.

Austin Butler

Austin Butler

Austin is a Senior Go-To-Market Specialist at Amazon Web Services (AWS) focusing on generative AI across the software development lifecycle. He works with strategic customers and partners to understand their software development practices and how AWS services like Kiro can deliver value in their SDLC. Prior to joining AWS, Austin spent 10 years working in Finance & Accounting.