Add learning
Give an agent one tool that updates learned weights without exposing routing authority.
Begin with normal model calls. Add internalize when the agent encounters durable knowledge that should influence future answers. The tool submits a learning job; it does not inject the passage into later context.
Choose an identity once
Use a stable subject for the customer, workspace, or assistant whose knowledge should evolve. Resolve that identity in your trusted server code. The model should supply knowledge, not decide whose weights to change.
Create an Inference + learning key for a server that needs both operations. It can poll its own jobs and request activation of the candidate it creates. It cannot manually switch arbitrary retained versions or list the entire project's activity. Use a separate management key for release automation.
Register a small tool
This definition works with ordinary function-calling runtimes:
{
"type": "function",
"function": {
"name": "internalize",
"description": "Learn durable knowledge for this agent. Wait for the result and check activation before relying on it.",
"parameters": {
"type": "object",
"properties": {
"content": { "type": "string", "minLength": 20, "maxLength": 16000 }
},
"required": ["content"],
"additionalProperties": false
}
}
}Your handler validates the content and submits:
{
"subject_id": "AUTHORIZED_SUBJECT_FROM_YOUR_SERVER",
"content": "THE_VALIDATED_TOOL_ARGUMENT",
"max_cost_microusd": 5000000,
"activate": true
}Send it to POST /v1/internalizations, authenticated with the learning key. Supply a stable Idempotency-Key saved with the tool invocation. The model never receives that credential.
Wait for the actual outcome
Persist the accepted job ID before waiting. Poll /v1/jobs/{id} with the same key. For short-lived agent handlers, return a structured pending result and have your runtime observe the job durably.
A ready result means a validated candidate was saved. Inspect result.activated: only successful activation changes routing. A concurrent update can leave a ready candidate inactive, with activation_conflict: true. Let an application policy or operator resolve that conflict; avoid a model loop that repeatedly overwrites versions.
Learning has no per-call fee. Set max_cost_microusd in your application; measured compute is charged even when validation rejects the candidate. Initial hosting is included within that limit. Failed or rejected learning does not represent learned knowledge. Reconciliation requires inspecting the existing operation, not repeating it.
Workspace helper
The private repository includes @internalize/sdk; it is not a published npm package. Authorized monorepo consumers can bind the subject with a helper:
import { InternalizeClient } from "@internalize/sdk";
import { createInternalizeTool } from "@internalize/sdk/tool";
const client = new InternalizeClient({
baseUrl: "https://convergingthought.com",
apiKey: process.env.INTERNALIZE_LEARNING_KEY!,
});
const learning = createInternalizeTool(client, authorizedSubject, {
maxCostMicrousd: 5_000_000,
});
// Register learning.definition with your runtime.
// Save invocationId durably before the handler runs.
const result = await learning.execute({ content }, invocationId);The helper rejects extra arguments, so model input cannot override its bound subject. It returns the actual job state and activation result. External applications can implement the same small handler using HTTP.
Continue with a fresh question
After activation, make a Chat Completions request with the same subject header or body field. Leave the source passage out. Keep any current conversation history your application needs.
The adapter stores learned behavior in weights; it is not a document store or a guarantee of perfect recall. Keep provenance and source material in your application and evaluate important behavior. You can inspect learned versions, validation counts, and activation in Memory. There is no separate Memory area to keep synchronized.