PowerContext

Context that stays with the work — across sessions, agents, and people.

English · 中文 · 日本語

Website · Quickstart · Integrations · Benchmarks · Interfaces

What is PowerContext?

PowerContext is an open-source context service for AI agents. It keeps the durable part of your work — decisions, constraints, evidence, progress — outside any single conversation, so the next session, the next agent, or the next person can pick up from the current state instead of rereading the transcript.

Work rarely ends with whoever starts it. You hand a task to an agent, the agent gets part of the way, and later you or someone else takes over. The reasoning and current state often stay behind in that conversation. PowerContext moves them out of the conversation and into revisioned artifacts you can inspect:

Everything belongs to a Scope — one isolated Source journal, Memory lifecycle, review inbox, and Handoff history. A Scope ID selects data; it does not prove user identity, grant tool access, or authorize execution.

Scope
├── Source journal    # evidence: prompts, documents, work contracts, task outcomes
├── Memory            # atomic-memory/ARTIFACT_ID@REVISION — decisions, constraints, next steps
├── Review Inbox      # pending Experience and Skill candidates awaiting a decision
├── Handoff history   # handoff/ARTIFACT_ID@REVISION — work continuity across sessions
└── Topic Memory      # extracted in the background from eligible Sources

The Dashboard screenshots below use synthetic demonstration records.

Memory — decisions and constraints that outlive a session

Memory is a revisioned Artifact family for reusable decisions, constraints, facts, state, and next steps. An entry is active, forgotten, merged, or retired. Forgetting one through POST /v1/atomic-memory/lifecycle takes it out of active recall while its content and history stay available and restorable, without advancing the content revision. Explicit Memory writes need no model at all; extraction from captured Sources needs a configured generation pipeline.

"Don't refactor the old auth module — mobile is still using it." Context this expensive shouldn't depend on someone repeating it in every session.

Handoff — the current state, not the whole transcript

Handoff records work continuity as a four-step loop:

Work Contract → Prepared Handoff → Acknowledgement → Task Outcome

handoff_current_work captures an inspected boundary and returns a temporary Prepared Handoff. Committing it creates a durable Revision only when the user wants a milestone. The receiver resolves the Handoff and records an Acknowledgement; a Task Outcome preserves the final status and checks as Source evidence. The Handoff Report projects the latest Revision in each selected Scope — read-only, and it never rewrites Memory.

Experience — what worked, reviewed before it is reused

An Experience records a situation, an action, an observed outcome, and a reusable lesson. It enters a scope-local Review Inbox as a pending Candidate. Review writes use expected_version, so a decision cannot silently apply after another writer changes the proposal. Approval writes an immutable Revision; rejection records a reason. Both are terminal, and only the approved current head takes part in recall — pending, rejected, and historical Revisions are excluded.

Skill — a reviewed procedure, exported on purpose

A managed Skill holds a name, a discovery description, instructions, validation checks, and lineage. Approval does not install or execute it: an exact approved Revision must be exported explicitly before an Agent host can discover the host-local projection.

Why PowerContext?

• Context lives outside the conversation. Memory, Handoff, Experience, and Skill are server-side artifacts, not files inside one agent's home directory. Switch from Codex to Claude Code — or hand the work to a teammate — and the work travels with you.
• Everything is revisioned and traceable. Each Artifact is addressed as FAMILY/ARTIFACT_ID@REVISION. The Artifact ID stays stable while approved replacements create later Revisions, and reading an exact reference returns that historical snapshot even after the family head advances.
• Generation, review, and execution are separate steps. A model proposes content, review approves a Revision, and export creates a host-local copy. None of those steps grants an Agent permission to execute instructions. See Interfaces for what each surface exposes today.
• Recall is bounded, not dumped. PreparedContext selects active Memory and approved Experience heads for one Agent turn, applies a shared byte budget, and returns ready content or empty. Recalled content is history, not an instruction authority: the receiving Agent still follows current instructions and checks live workspace state.
• Review before reuse. Experience and Skill pass through a review decision that is terminal either way. The model proposes rather than silently promoting its own output.
• One Server, several views of the same contract. HTTP is the complete remote application contract. The Python Client gives typed access, MCP is a curated Agent-facing projection, and Core protocols let an application assemble its own Source, Artifact, and Trigger implementations.

How it compares

	Re-reading chat history	RAG over transcripts	Host-local memory files	PowerContext
Survives a new session	manual	yes	yes	yes
Survives switching agents	no	no	no	yes
Handing work to a person	manual	manual	manual	Handoff, first-class
Reusable procedure	no	no	prose only	Experience / Skill
Earlier revisions kept	no	depends on the index	only via git	immutable Revisions
Review before reuse	n/a	no	no	Review Inbox
Bounded recall for one turn	no	partial	no	PreparedContext byte budget
Inspectable outside the Agent	no	no	yes	yes

Proof it works

• Long-conversation memory (LoCoMo): 90.78% accuracy, against 87.79% for PowerMem and 52.9% for full-context replay — +37.88 points over full context.

• Coding tasks (SWE-bench Pro): 86.73% task resolution with PowerContext on, 82.35% with it off — +4.38 points and 32 more tasks resolved in a 731-task paired run.

• Retrieval quality (LoCoMo Plus), native PowerContext against PowerContext with Jev candidate filtering after retrieval. Each model is used for both Memory extraction and answering; embeddings use qwen3.7-text-embedding (1024 dimensions):

  Model	PowerContext	PowerContext + Jev	Difference
  GPT-4o-mini	40.855%	49.78%	+8.925 points
  Qwen3.7-plus	60.37%	68.947%	+8.577 points
  GPT-4o	65.082%	69.28%	+4.198 points

Full methods, results, and limitations: benchmarks. Two caveats we would rather state than bury: the six LoCoMo Plus scores above were supplied by the project owner, and their run artifacts are not publicly available for verification — the published instructions reproduce the harness, not those scores. Windows support is experimental.

Quick start

PowerContext 1.3.0 includes an interactive setup wizard. You need Git, uv, and your Agent's CLI. Python 3.11+ is required; uv can provision it. macOS and Linux are supported; Windows support is experimental.

Run the wizard in a dedicated directory

uv tool install --force "powercontext[cli,server]==1.3.0"
mkdir -p powercontext-config && cd powercontext-config
powercontext config init --language en --output .env
powercontext server run --env-file .env      # keep this terminal open

The wizard writes one .env environment file and .env.next-steps.md. Keep Server running; in another terminal, return to powercontext-config, load only the client settings, and check the connection:

set -a
. ./.env
set +a
powercontext ready
powercontext capabilities

Continue with .env.next-steps.md to create and bind the selected Scopes, install the matching plugins, and launch a new Agent session. The complete walkthrough covers Codex and Claude Code, Dashboard login, SSH forwarding, HTTPS prerequisites, and observable acceptance checks. For example, the matching Codex installation is:

powercontext setup codex --ref powercontext-v1.3.0
powercontext doctor codex

Explore in Python first — no API key

The tutorials run from a repository checkout and take their dependencies from a uv dependency group, so they are not part of the powercontext package. From the repository root:

uv sync --locked --group notebooks
uv run --locked --group notebooks jupyter lab --notebook-dir=examples/jupyter

Then work through the 22 Chinese Jupyter tutorials and a complete team workflow to run Memory, context preparation, Handoff, Experience, Skill, and a real Agent step by step. The first seven tutorials need no model or API key.

Before you ask "why isn't it working?"

• doctor verifies integration setup. To verify automatic memory, check that a real prompt becomes a Source, produces a Topic, evolves after a related prompt, and can be recalled in a new session using the same Scope.
• If Python dependency downloads are slow or fail, configure a package index for uv and retry.
• Choose Full memory capabilities to test automatic Memory and Topic Memory; this requires separate Generation and Embedding API credentials. An Agent subscription does not provide those Server credentials. Choose Basic memory to save and retrieve memories explicitly without additional model APIs.
• If seekdb needs installing, the wizard asks once and installs the dependency in the background.
• The optional recall-sufficiency gate records scope-local daily search effort and budget omissions for later policy evaluation. See the configuration reference for its recording and failure behavior.
• For a Server on another machine, use HTTPS or follow the remote connection guide. Setup recognizes remote HTTP URLs from flags or environment variables and asks for explicit consent; automated setup uses --allow-insecure-http.

Connect your Agent

Codex is official; other maintained hosts and Python Agent frameworks are community; Bub is evaluation only. These tags describe PowerContext integration maintenance and use. The capability matrix records which hosts are qualified, along with their supported features and availability.

Codex	Claude Code	MiniMax Code	DeepSeek Harness	ZCode	Kimi Code	Hermes Agent	Pi Coding Agent
OpenClaw	OpenCode	WorkBuddy	Bub	Pydantic AI	LangChain	LangGraph

Applications can use PowerContext through the async Python client, HTTP API, MCP, or the in-process Core SDK. See the interface reference to choose an entry point.

Build PowerContext

make install
make check
make test

See CONTRIBUTING.md for the complete development workflow. Coding and memory evaluations, performance benchmarks, and Skill regressions live under evaluation/.

Learn more

• Get started
• Connect Agents
• Manage context
• Deploy and operate
• Develop with APIs

PowerContext is the successor to PowerMem.

Contributors

Thank you to everyone who contributes to PowerContext. ❤️

See all contributors · Start contributing

License

PowerContext is licensed under the Apache License 2.0.