Skip to main content

Kam State · Planned for AWS Marketplace

The State add-on for Amazon Bedrock AgentCore.

Kam State is designed to save engineering time and reduce custom infrastructure costs with versioned state, recorded inputs, and recovery of accepted State processing. Your application controls execution.

Plan an evaluationExplore real NFL results

Prelaunch · Private SDK evaluation · Hosted service not yet available.

Less infrastructure work. More time to build.

Build fewer state controls.

Evaluate a reviewed foundation for exact versions, scoped reads, and supported retries. Compare it with building and maintaining equivalent controls in your application.

Inspect changes with exact evidence.

Open a recorded version and its input references. Compare a correction with the earlier record while both remain retained and authorized.

Focus state updates.

Declared dependencies identify affected Views. Kam retains reconciliation progress; your application still controls models, tools, and external effects.

Designed to reduce engineering and operating effort. Measure savings against your workflow and total cost.

Inspect real NFL results and their sources.

Explore captured scores, sportsbook closing spreads and recorded results in one workspace.

Five games · captured October 26, 2026. Saved public API responses. This snapshot does not update.

Free products by Kam AI.

Explore the product line →

A State add-on for your AgentCore application.

  1. Your application and sources

    Own domain data, decisions, model calls, and external effects.

  2. Amazon Bedrock AgentCore

    AgentCore Runtime hosts your agent code. AgentCore Memory handles conversational and long-term memory.

  3. Application-controlled adapter

    Supplies outcomes and exact input references. Automatic runtime interception remains planned.

  4. Kam State

    Keeps accepted revisions, versioned membership, and receipts. DynamoDB is authoritative for Kam’s stored state.

Use the SDK to add Kam State to your AgentCore application. AWS Marketplace is the planned purchasing channel. The read-only console inspects recorded state.
Review ownership and data flow

Read an exact version. Browse a fixed, versioned list.

byIds

Retrieve the requested retained revision or an explicit unavailable result. Never substitute latest.

allIds

Enumerate bounded membership pinned to a published generation. Keep that generation across pages.

Scoped authorization, dependency integrity, conditional publication, and accepted-work recovery compose around these reads.

History contract today. Generalized objects and collections remain planned.

Review SDK contracts and failure cases

Evidence, security, and performance limits

Review qualification, security and measurement limits
  1. Source implementedRecorded
  2. Locally qualifiedSelected artifacts
  3. Cloud-qualifiedNot established
  4. Production commitmentNot offered

Scope and authority

The service authorizes each scoped read; stale authority grants no access. Missing required evidence blocks current State or complete Context.

Security & SOC 2 roadmap

Bounded work; cloud p99 unmeasured

History reads and State queries have fixed work bounds. No measured cloud p99 is published for this release.

Review measurement

Source and local evidence do not establish cloud qualification or a production commitment.

Check evidence and limits

One application. One workflow.

Evaluate Kam State for your AgentCore application.

Bring one workflow with a correction or retry. Agree the baseline, scope, and success checks before starting.

Plan an evaluationRead the evaluation scope
Before Kam, and after

Shared results go missing or drift.

Root problem: cause → costWith Kam: the recorded contract

Copies drift.

Each agent keeps a copy.Copies differ.

  • Stale reads
  • Lost versions
  • Double counts

Request an exact version. Supported retries add no duplicate.

Inputs go missing.

Sources change.The input is lost.

  • Lost inputs
  • Lost sources

Inspect saved inputs. Your app records them; retention applies.

Work gets redone.

Changes are hard to trace.Work repeats.

  • Full rebuilds
  • Repeat calls

Identify affected Views. Kam recovers its accepted State processing. Your app verifies external effects.

Who builds the State controls?

  1. 1

    Re-read your sources

    You build the controls.

    • Exact reads: you build it
    • Old versions while retained: you build it
    • Supported retry checks: you build it
    • Declared change tracking: you build it
    • Access on each read: you build it
    • AgentCore setup: you build it

  2. 2

    Your database plus custom code

    You build it.

    • Exact reads: you build it
    • Old versions while retained: you build it
    • Supported retry checks: you build it
    • Declared change tracking: you build it
    • Access on each read: you build it
    • AgentCore setup: you build it

  3. 3

    Kam

    Supported controls in source.

    • Exact reads: built in
    • Old versions while retained: built in
    • Supported retry checks: built in
    • Declared change tracking: built in
    • Access on each read: built in
    • AgentCore setup: you build it

means you build and maintain it yourself. Categories, not named products.

Start from your role

Principal engineer

Which correctness mechanisms does Kam own, and which remain mine?

Exact revisions, conditional commits, retry receipts, and explicit failure cases.

Implemented in source · Evaluation access only

Your application owns domain meaning and external-effect idempotency.

Review correctness and ownership →
Related evidence

ML engineer

Which evidence was supplied, and what changes after a correction?

Versioned Context manifests, retained inputs, and synthetic correction fixtures.

Implemented in source · Evaluation access only

Recorded evidence does not prove model consumption or reproducible model output.

Review Context evidence →
Related evidence

AI engineer

How does my AgentCore application integrate and recover accepted work?

Scoped SDK calls, record/retry/correction examples, and durable reconciliation.

Implemented in source · Evaluation access only

Private SDK. Your runtime owns execution and uncertain external effects.

Review SDK integration →
Related evidence
See the available contracts
What one agent turn records
Built to add on to AWS

Amazon Bedrock AgentCore

Runs the agent. Kam keeps State.

Your databases

Keep your databases.

Data flow

Where data moves, and where access is checked.

Kam data flow. Your application records results and agents read exact versions through the Kam History API, which checks access on every call. The Rust State engine keeps exact revisions and Views, and writes to DynamoDB with conditional writes. Publishing to AgentCore Memory is optional and off by default.

  • Your systems of record: databases · services
  • Your application: records results
  • Agent on AgentCore: reads through the Kam SDK
  • Kam console: browser → /console/api
  • Kam History API: access checked on every call
  • Rust State engine: exact revisions · Views
  • Amazon DynamoDB: authoritative storage
  • AgentCore Memory: optional · off by default
  • Your systems of record → Your application
  • Your application → Kam History API (record)
  • Agent on AgentCore → Kam History API (read exact)
  • Kam console → Kam History API (read-only)
  • Kam History API → Rust State engine
  • Rust State engine → Amazon DynamoDB (conditional write)
  • Rust State engine → AgentCore Memory (publish)
Implemented in source; not a live deployment. The console uses only read routes.