Skip to main content

Kam State · Infrastructure for AWS agent applications

State Management for Amazon Bedrock AgentCore

Immutable accepted History, exact revisions, and bounded State access. Keep your domain logic and existing sources. Kam preserves, retrieves, and inspects the State your application records.

Explore the reference workflowReview the SDK and contracts

Prelaunch. Explore the example or request a technical evaluation.

A reference workload for versioned State.

Inspect corrections, exact evidence, and explicit incompleteness in a fictional football workflow.

Public example · synthetic data · no model execution

Loading the recorded example.

Free products by Kam AI.

Explore the product line →

Where State lives. Who owns execution.

  1. Your application and sources

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

  2. Amazon Bedrock AgentCore

    Hosts your agents and tools. Memory owns recall.

  3. Application-controlled adapter

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

  4. Kam State

    Keeps accepted revisions, membership, and receipts. DynamoDB is authoritative.

The SDK is the integration surface; the read-only console inspects its contracts.
Review ownership and data flow

Exact revisions. Generation-pinned membership.

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

Qualification, security, and cloud p99

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.

Review security

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 the result you need to inspect.

Bring a correction or retry. Agree the scope, evidence, and success check 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

Find declared dependent work. Kam resumes accepted work. Your app checks 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.