Three releases in twenty days and two version pins to keep in agreement
Not only memory but a full story.
At a glance
- What is it?
- PowerContext is OceanBase's Python project for keeping context with a piece of work across the conversations and people or agents that pick it up, storing durable facts as Memory and the current objective as a Handoff. What the repository documents is a setup that pins two different versions at once, a runtime core with three dependencies and extras that carry the weight, two separate opt-ins required before a server leaves loopback, and an acceptance check that is an entity chain rather than a test suite.
- Who is it for?
- PowerContext is aimed at a specific failure: work handed to an agent, abandoned halfway, and resumed later by someone or something with no memory of the reasoning. If that is your situation, the model is legible, with Memory for durable facts, Handoff for the current objective, and Experience and Skill for reusable approaches, all scoped and all carrying their sources.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- oceanbase/powercontext1,665 ★ · +688
| Repository | 2026-09-12 | 2026-11-15 |
|---|---|---|
| oceanbase/powercontext | 977 | 1.7k |
688 Stars in the last 64 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The install pins a package version and a git ref
Three releases exist inside three weeks: PowerContext v1.0.0 on 2026-09-11, v1.1.0 on 2026-09-21, and v1.2.0 on 2026-09-30. The documented install pins the first one explicitly, and uses `--force` so an earlier tool install is replaced rather than skipped:
uv tool install --force "powercontext[cli,server]==1.2.0"
mkdir -p powercontext-config
cd powercontext-config
powercontext config init --language en --output .envThe agent setup then pins the second, as a git reference rather than a package version:
powercontext setup codex --ref powercontext-v1.2.0
powercontext doctor codexSo a working install carries two version references that must agree, one resolved from the package index and one resolved from a tag. The page states that 1.2.0 is the version that includes the guided setup, which is the reason the pin exists, and with a release every week or so the two references are something to move deliberately.
The runtime core has three dependencies and the extras do the work
The core dependency list is `pydantic>=2.10,<3`, `rfc8785>=0.1.4,<1`, and `typing-extensions>=4.12,<5`. The middle one is worth noting: rfc8785 is the JSON Canonicalization Scheme, which is the kind of dependency a system reaches for when it signs or hashes records rather than when it merely reads configuration. The version is declared dynamic rather than written into the file, and the keywords list holds a single entry, `python`.
Everything else is behind extras. The `code` extra carries static analysis and process metrics: `tree-sitter==0.26.0` with grammars for Go and JavaScript and Python at `0.25.0` and TypeScript at `0.23.2`, plus `psutil>=7.2,<8` guarded by `sys_platform == 'darwin'`, so the process measurement is macOS-only. The grammar versions do not match the base pin, and the TypeScript grammar sits two minor series below the Go and Python ones. The `builtin` extra brings `aiosqlite`, `apscheduler`, `jsonschema`, `packaging`, and `pydantic-ai-slim[anthropic,openai]`, which is where the model clients live.
Leaving loopback takes two separate opt-ins
The environment template ships with conservative defaults and two escape hatches, and the comments on both say what they are for. Out of the box the server binds `POWERCONTEXT_SERVER_HTTP_HOST=127.0.0.1` on port 8000, with `POWERCONTEXT_SERVER_MCP_ENABLED=true` and `POWERCONTEXT_SERVER_MCP_PATH=/mcp`, so an MCP endpoint is on by default but only on the local interface.
The first opt-in is `POWERCONTEXT_SERVER_ALLOW_INSECURE_HTTP`, commented out and set to false, described as a development or proof-of-concept escape hatch that permits direct cleartext HTTP for remote Skill Receiver endpoints. The Receiver has to enrol with `--allow-insecure-http` as well, and the template says to keep it false on public or untrusted networks. The second is independent: `POWERCONTEXT_SERVER_ALLOW_UNAUTHENTICATED_NON_LOOPBACK=false`, required for a direct non-loopback bind when Server-wide bearer authentication is not in place.
Two related settings complete the picture. `POWERCONTEXT_SERVER_WORKSPACE` defaults to the directory where the Server starts and is meant to be set explicitly for services and containers, and `POWERCONTEXT_SERVER_PUBLIC_URL` is set once when remote receivers must reach a remotely addressable endpoint. The configuration walkthrough separately warns that a remote server needs HTTPS or the remote connection guide.
A static token is labelled legacy and access mode is the only switch
Access control in the template is arranged so that there is one live path and one compatibility path. `POWERCONTEXT_SERVER_ACCESS_MODE=disabled` is marked as the only supported Access Control switch, and everything else in that section is described in terms of it. Below that, `POWERCONTEXT_SERVER_AUTH_ENABLED=true` and `POWERCONTEXT_SERVER_AUTH_TOKEN=replace-me` appear commented out and labelled legacy static Bearer compatibility, with the note that an injected Authentication Provider takes precedence over them.
The deployment identity sits alongside: `POWERCONTEXT_SERVER_ACCESS_DEPLOYMENT_ID=powercontext`, which is what a Deployment-level setting would key on, and the file is grouped under an Access Control heading that continues past what is visible here. The pattern is consistent with the two opt-ins elsewhere in the file: the default is the narrow one, the wider behaviours are named, commented out, and each carries its own condition.
A separate note governs the home directory. Leaving `POWERCONTEXT_HOME` unset uses the stable operating-system user data directory, and setting it to an absolute path relocates the data, which is what the services and containers need.
Full memory needs credentials an agent subscription does not include
The configuration wizard asks about storage, local or remote access, memory capabilities, the Dashboard, model APIs, and Agent connections. The memory choice is the one with a price attached. Choosing Full memory capabilities, which is what the page recommends in order to test automatic Memory and Topic Memory, requires separate Generation and Embedding API credentials, and the page says plainly that an Agent subscription does not provide those Server credentials. Choosing Basic memory saves and retrieves memories explicitly and needs no additional model APIs.
So there are two different products in one box: a capability that depends on the model endpoint you already pay for, and a capability that is explicit retrieval only. The wizard writes one `.env` file and one `.env.next-steps.md`, and if seekdb needs installing the wizard asks once and installs that dependency in the background, after which the printed connection details are followed and the Server is started in the same terminal:
powercontext server run --env-file .envThe acceptance check is a chain of entities, not a test suite
Verification is described in terms of what should appear in the data. `doctor` verifies the integration setup, and the memory check is a four-step observation: a real prompt becomes a Source, it produces a Topic, the Topic evolves after a related prompt, and it can be recalled in a new session using the same Scope. That is the whole acceptance criterion stated on the page, and it is a different shape from a passing assertion.
The completion check for the installation is a shell sequence that loads only the client settings into the environment and asks the client what it can see:
set -a
. ./.env
set +a
powercontext ready
powercontext capabilitiesThe written walkthrough then continues with `.env.next-steps.md` to create and bind the selected Scopes, install the matching plugins, and launch a new Agent session, with the linked guide covering Codex and Claude Code, Dashboard login, SSH forwarding, HTTPS prerequisites, and observable acceptance checks. For learning the model rather than installing it, there are 22 Jupyter tutorials in Chinese covering Memory, context preparation, Handoff, Experience, Skill, and a real Agent step, of which the first seven need no model and no API key.
Integration support is tagged and three of them sit outside the docs tree
Thirteen integrations are listed with a maintenance tag attached. Codex is `official`, other hosts and Python Agent frameworks are `community`, and Bub is `evaluation` only, with the tags described as covering both integration maintenance and use. The grid names Codex, Claude Code, DeepSeek Harness, ZCode, Hermes Agent, Pi Coding Agent, OpenClaw, OpenCode, WorkBuddy, Bub, Pydantic AI, LangChain, and LangGraph.
The documentation paths are not uniform. Most integration guides sit under `docs/en/docs/integrations/`, while Hermes Agent, WorkBuddy, and Bub are documented by a README inside their own `integrations/` directory, which is the same split the package layout uses. Applications reach the system through four entry points: an async Python client, an HTTP API, MCP, or the in-process Core SDK.
Two platform and tooling details close the picture. macOS and Linux are supported while Windows is marked `experimental`, and Python 3.11 is required with uv able to provision it. Agent skills are installed from `skills-lock.json` through a Makefile target that runs `npx skills experimental_install` and then tells you to restart Codex, so even the recommended skills are installed by a command the project itself labels experimental.
Editorial conclusion
PowerContext is aimed at a specific failure: work handed to an agent, abandoned halfway, and resumed later by someone or something with no memory of the reasoning. If that is your situation, the model is legible, with Memory for durable facts, Handoff for the current objective, and Experience and Skill for reusable approaches, all scoped and all carrying their sources. Verify three things before you commit to it. The install pins the package to one version and the agent setup to a git ref, so the two must be moved together, and with three releases in under a month that will come up. Full memory needs Generation and Embedding credentials that an agent subscription does not supply, so budget for a second set of keys or use Basic memory. And exposing the server takes two independent confirmations, one for cleartext HTTP to remote receivers and one for a non-loopback bind without bearer authentication.
Frequently asked questions
What does PowerContext actually store?
Durable information as Memory, the current objective and state organized into a Handoff, and reusable approaches as Experience or Skill. Every item is kept within the scope of the work and preserves its sources and earlier revisions, and a returning session is shown confirmed decisions, constraints, progress, evidence, and next steps rather than the full history.
What do I need to install PowerContext?
Git, uv, and your Agent's CLI. Python 3.11 or newer is required and uv can provision it; macOS and Linux are supported while Windows is `experimental`. The documented sequence installs `powercontext[cli,server]==1.2.0` with uv, creates a dedicated `powercontext-config` directory, and runs `powercontext config init --language en --output .env` there.
Does PowerContext need model API credentials?
Only for full memory capabilities. That choice requires separate Generation and Embedding API credentials, and the page states that an Agent subscription does not provide those Server credentials. Basic memory saves and retrieves memories explicitly and needs no additional model APIs.
How do I expose a PowerContext server to other machines?
Set `POWERCONTEXT_SERVER_PUBLIC_URL` for a remotely reachable endpoint and use HTTPS, or follow the remote connection guide. Setup recognises remote HTTP URLs from flags or environment variables and asks for explicit consent, and automated setup uses `--allow-insecure-http`. A direct non-loopback bind without Server-wide bearer authentication also needs its own opt-in, `POWERCONTEXT_SERVER_ALLOW_UNAUTHENTICATED_NON_LOOPBACK`.
Which agents does PowerContext support?
Thirteen are listed with maintenance tags: Codex is `official`, other hosts and Python Agent frameworks are `community`, and Bub is `evaluation` only. The grid covers Codex, Claude Code, DeepSeek Harness, ZCode, Hermes Agent, Pi Coding Agent, OpenClaw, OpenCode, WorkBuddy, Bub, Pydantic AI, LangChain, and LangGraph, and applications reach them through an async Python client, an HTTP API, MCP, or the in-process Core SDK.
Official sources
Where developers are discussing it
Posts on Hacker News, dev.to and Lobsters that link to this repository, found by our scan of those communities. 0 in the last 30 days; newest first.
- PowerContext, Context for work that humans and agents hand off and continueHacker News · Sep 15, 2026 · 1 points · 0 comments
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/oceanbase-powercontext)Star history chart for your README
[](https://hysenlabs.com/projects/oceanbase-powercontext)Was this useful?