Skip to main content

Evaluation

Prove one accepted operation before expanding.

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.

Review the integration and access requirements →

Agree the evaluation before you start.

Scope
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.

  1. 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.

  2. 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.

  3. 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.

Inspect the Fasting Free workflow →

National Parks Nearby

Changing sources: retain, compare, inspect.

  1. Keep the saved source version

    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.

  2. Report a missing version

    Request a version that is unavailable. Confirm the application reports the gap without substituting current data.

  3. 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.

Inspect the National Parks Nearby workflow →

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.

StageCheck referencesReadiness
request@1 · eligibility@1request@1current
request@2 · eligibility@1request@1blocked
request@2 · eligibility@2request@2current

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.

  1. 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.

  2. 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.

  3. 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.

  4. 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.

hello@kam-ai.com

Customize your inquiry

This page does not send or save your draft. Copy it or open your email app when ready. Use Clear draft to remove it.

Evaluation inquiry draft
Email an evaluation inquiry ↗

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?

  1. Review one workflow and its recorded inputs.
  2. Confirm the producer adapter, environment, and access requirements.
  3. Agree scope and price, then run the checks and review the deliverables.
Compare behavior, effort, ownership and cost.
  1. 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.

  2. Integration effort

    Record engineering time for setup, source mapping, adapters, tests and operational configuration. Include migration work needed for a usable comparison.

  3. 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.

  4. 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.

Enterprise procurement plans

Review planned enterprise controls (not available)

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
ClaimStatusBasis
Built to work with Amazon Bedrock AgentCoreAccurate todayKam’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 servicesAccurate todayThe implementation stores authoritative State in Amazon DynamoDB. A publicly offered hosted service is not available.
Listed in AWS MarketplacePlanned · no listing availableMarketplace is the planned purchasing channel. There is no listing, so no Marketplace badge or “Buy with AWS” button is shown.
Partner status with AWSNot yetKam does not hold partner status in an AWS partner program and does not use partner language.
Used, endorsed, or certified by AmazonNot claimedAmazon 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.