Bring one AgentCore workflow with a timed-out save or changed input. Agree the SDK calls, expected revisions, retry behavior, and exact readback. Inspect what Kam accepted and what remains unresolved. Keep your harness and compare the integration effort, remaining responsibilities, and total cost.
Prelaunch · Private SDK evaluation · Hosted service not yet available.
One application, one workflow, its sources and supported operations.
Your engineer
Provide an example and integration owner. Agree access and configuration work.
Duration
Agree the evaluation period and working sessions.
Environment
Agree the private artifact, non-production environment, access boundaries and source adapter.
Deliverables
An integration example, recorded results, baseline comparison, ownership map and deployment requirements.
Success checks
Verify behavior, measure integration effort, list remaining responsibilities, and compare total cost against the same baseline.
Price
Agree a quote in the written scope before starting. Public production plans and usage prices are not offered.
Next step
Review failed or unresolved checks before further integration or deployment.
Agree these outputs and pricing in writing before the evaluation starts.
Optional examples: corrections and changing sources
Use these application workflows to define a small evaluation. Agree which checks your application owns and which the selected Kam contract supports.
Fasting Free
Personal records: retry, correct, import.
Retry after an uncertain save
Repeat a supported write after losing its response. While its evidence is retained, verify a duplicate does not create another accepted revision; inspect the receipt and resulting revision.
Correct from a stale revision
Change a record on one client, then submit a correction from an older revision. Verify rejection and preserve unconfirmed work for review.
Import only with consent
Keep guest records local at sign-in. Authorize an import; clear an unchanged local copy only after confirmed readback. Preserve it if confirmation fails.
Your application owns identity, queues, conflict review, import consent and readback.
Save a source reference, publish a later version, then reopen the saved plan. Verify that it resolves the original retained object and its content hash.
Report a missing version
Request a version that is unavailable. Confirm the application reports the gap without substituting current data.
Distinguish change from missing evidence
Compare successful source checks with failed checks. Record a coverage gap when a check fails; a failed observation must not establish “no change.”
Your application owns collection, source interpretation, retention and conditional publication.
These first-party apps embed Kam’s Rust kernel with application-owned persistence. Their behavior does not qualify hosted Kam History or a live AgentCore integration. Evaluate the selected SDK, endpoint and environment separately.
Preview the result you can inspect
This refund-agent example shows when an eligibility check stops matching a changed request. Compare refresh work, repeated tool calls, and investigation time against your baseline.
Stage
Check references
Readiness
request@1 · eligibility@1
request@1
current
request@2 · eligibility@1
request@1
blocked
request@2 · eligibility@2
request@2
current
Synthetic contract evidence; no refund or agent execution. Qualify the producer adapter, tool integration and application action checks separately.
Inspect configuration, execution and remaining requirements
Synthetic observations supplied directly to Rust. This does not prove SDK acceptance, persistence, agent execution, or a deployed service.
Requires an authorized endpoint and a producer adapter for retained request/eligibility Observations. Configuration is not convergence. History sourceRefs do not supply trusted dependency witnesses.
Prepare one evaluation: inputs, expected results and failure checks
Use the existing recorded contract example to agree what your first evaluation must show.
Bring one problem
Name the source, integration owner, correction or retry, and one observable success check. Keep credentials and customer records out of the inquiry.
Inspect the saved result
The public refund example records current → blocked → current. It also rejects an altered candidate. The application still owns tool calls and refunds.
Arrange the required access
Contract replay needs Python 3 and the approved private Linux x64 worker. SDK calls separately need a reviewed artifact, authorized endpoint and source producer; none is granted by this page.
Keep the failures with the result
Check supported duplicate receipts, corrections and exact retained reads in the agreed environment. Record missing evidence or access as unresolved. Compare effort and total cost before claiming savings.
A recorded contract result does not establish SDK acceptance, persistence, AgentCore execution or a deployed service.
Start with a short note.
Send your work email, current data source, and the workflow or problem. No credentials, raw customer data, or architecture document are needed to start.
Do not include credentials, private records or customer data. Nothing is submitted by this page.
An inquiry does not activate a subscription or service access.
What happens after your inquiry?
Review one workflow and its recorded inputs.
Confirm the producer adapter, environment, and access requirements.
Agree scope and price, then run the checks and review the deliverables.
Compare behavior, effort, ownership and cost.
Behavior
Run the same supported retry, correction and exact-reference cases against your current approach and the proposed integration. Record accepted results, rejected operations and unresolved evidence; define pass/fail before starting.
Integration effort
Record engineering time for setup, source mapping, adapters, tests and operational configuration. Include migration work needed for a usable comparison.
Remaining responsibilities
Produce an ownership map for application logic, identity, source collection, persistence, retention, conflict handling, recovery and operations. Identify what Kam takes on under the agreed contract and what your team still maintains.
Total cost
Compare implementation and maintenance effort, investigation time, repeated tool calls, Kam fees, cloud usage and operations over an agreed period. A useful outcome can be keeping your existing approach; no savings are established by the public examples.
For teams maintaining State controls
Start where your team already maintains retry handling, corrections or retained source references. Use AgentCore or your own backend; agree the producer adapter, authorized endpoint and application responsibilities before an end-to-end run.
AgentCore hosts your agent runtime; your application and framework choose model and tool calls. Kam keeps recorded State. Hosted usage billing and Marketplace offers are planned, not available services.
Customer and AgentCore responsibility
Execution
AgentCore + your application
AgentCore hosts your agent runtime. Your application and framework authorize actions, invoke models and tools, and own external effects.
Source-implemented · private evaluation
State integrity
Kam State
Reviewed source provides scoped exact History, supported retry checks, revisions, and recorded receipts. Hosted customer qualification remains open.
Planned hosted offer · not available
Commercial control
Proposed hosted billing
The hosted offer would connect contract allowances, usage attribution, and billing reconciliation. Source-level admission controls do not establish a production-qualified commercial service.
Proposed usage accounting
Proposed billing would derive units from accepted State operations with recorded receipts and stable operation identities. Retried requests would not create another charge. Admission limits must be checked before expensive work; a usage report alone does not cap spending. The meter and pricing dimensions still require implementation and customer validation.
Open-source software is not free infrastructure
An open-source chat UI and AG-UI do not require a paid orchestration platform. Execution, inference, storage, network transfer, and operations still cost money. Bounded context is not a hard cap on model spending; measure the full workload.
Proposed AWS Marketplace purchase path
The commercial hypothesis is annual enterprise contracts with negotiated capacity and optional metered overages through private offers. Eligible Marketplace spend may count toward an AWS commitment only under the buyer's agreement; no discount-program eligibility is promised.
Kam has no live AWS Marketplace listing, published enterprise usage rates, production SLA, or production-qualified hosted offering.
Kam and AWS, stated plainly
Kam State is an independent add-on for Amazon Bedrock AgentCore.
Review AWS relationship facts
Claim
Status
Basis
Built to work with Amazon Bedrock AgentCore
Accurate today
Kam’s design and source target AgentCore runtimes: Kam keeps State, AgentCore executes. The integration is implemented in source and not live-qualified.
Built on AWS services
Accurate today
The implementation stores authoritative State in Amazon DynamoDB. A publicly offered hosted service is not available.
Listed in AWS Marketplace
Planned · no listing available
Marketplace is the planned purchasing channel. There is no listing, so no Marketplace badge or “Buy with AWS” button is shown.
Partner status with AWS
Not yet
Kam does not hold partner status in an AWS partner program and does not use partner language.
Used, endorsed, or certified by Amazon
Not claimed
Amazon is not a Kam customer and has not endorsed Kam. A Marketplace listing would not change that.
AWS Marketplace is the planned way to buy. There is no live listing or one-click activation yet. An inquiry grants no AWS account access.