promptulate bets the whole API on one function, pne.chat
🚀Lightweight Large language model automation and Autonomous Language Agents development framework. Build your LLM Agent Application in a pythonic way!
At a glance
- What is it?
- A Pythonic agent framework from Cogit Lab whose stated core idea is that you should not spend time learning it: import promptulate as pne, call pne.chat, and reach for ToolAgent, CodeAgent or WebAgent when you need more. Model coverage is litellm's rather than its own, and the newest tag is 1.18.4 from October 2024.
- Who is it for?
- Adopt promptulate if you want an agent application in a few lines of Python, if you already use litellm-style provider strings, or if the terminal client and hook surface solve a specific annoyance in your current setup. The Python floor is low and the dependency list is short, so a trial is cheap.
- 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 last received commits 124 days ago.
- 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
- Undertone0809/promptulate513 ★ · +1
| Repository | 2026-09-13 | 2026-11-15 |
|---|---|---|
| Undertone0809/promptulate | 512 | 513 |
1 Stars in the last 63 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The whole API is one function, and that is the design argument
Most frameworks ask you to learn a vocabulary before you get a result. promptulate inverts that, and the README does not hide the ambition: the stated core concept is to provide a simple, pythonic and efficient way to build AI applications so you do not spend a lot of time learning the framework, with pne.chat() doing most of the work and any AI application being a few lines of code. The features list backs that up rather than contradicting it, and the Pythonic code style entry says it plainly: everything is reachable through one pne.chat call that encapsulates the essential functionality. The stated philosophy is to borrow from the open-source community and integrate the highlights of various frameworks, which is an honest description of what a wrapper framework is, and the stated goal is to lower the barrier to entry and unify consensus among developers. The author is Cogit Lab, the project is licensed Apache-2.0, and the documentation site is promptulate.cn. If you accept that framing, the rest of the package is detail: agents, tools, hooks, a terminal client and a Streamlit component set, all reachable from the same import. One feature entry deserves a second look because it is a compatibility promise rather than a convenience: with pne you no longer need the openai sdk, since the core functions can be replaced with pne.chat, and the entry claims enhanced features on top. A framework that absorbs a vendor sdk can insulate you from its churn, and can also strand you when you need the one method it did not wrap. The README also carries a dated note about an OpenAI model launch in May 2024, which is a small signal about how quickly this kind of page ages.
pne is Promptulate with the middle nine letters removed
The short name is explained in the README, and the explanation is the kind of detail that tells you who wrote it. Below the architecture diagram there is a note that pne stands for Promptulate, which is the nickname for the project: the p and the e represent the beginning and the end of the name, and the n stands for 9, which is a shorthand for the nine letters between them. So the import you write is deliberately shorter than the package you install, and the module name is not a typo to be corrected. The distribution installs the package as promptulate and gives you two console scripts, pne and pne-chat, which point at two different client modules, promptulate.client.pne and promptulate.client.chat. That is worth knowing before you wire either into a script, because two similarly named entry points usually means one is the fuller client and the other is the narrower chat path. The repository is bilingual, with English and Chinese READMEs side by side, and the Python floor is low: the packaging metadata accepts 3.8.1 up to 4.0. The contributor plumbing has its own small oddity: the pull request template file is named PULL_REQUREST_TEMPLATE.md, misspelled, and a sweep.yaml sits at the top level for the lint-fixing bot, alongside a pre-commit configuration and a .vscode directory. None of that affects the library, and all of it is the kind of detail that tells you which projects are maintained by one person, which this one appears to be.
Model coverage is litellm's, reprinted as a capability table
The model support section does not enumerate anything of its own. It states that promptulate integrates the capabilities of litellm and supports nearly all types of large models on the market, then reproduces litellm's provider matrix with six columns: completion, streaming, async completion, async streaming, async embedding, and async image generation. The table is the honest way to see what you get, because the columns are uneven. openai, azure, aws sagemaker, aws bedrock, mistral, cloudflare AI Workers, cohere, huggingface, replicate, together_ai, openrouter, ai21, baseten, vllm, nlp_cloud, aleph alpha, petals, ollama, deepinfra, perplexity-ai, Groq AI and anyscale carry the full set of check marks. google AI Studio gemini is narrower, with gaps in the streaming and embedding columns. voyage ai and xinference appear only in the embedding column, which tells you they are for retrieval rather than chat. Anthropic covers the first five columns but not image generation. Since the strings are litellm's, the call is litellm's:
import promptulate as pne
resp: str = pne.chat(model="ollama/llama2", messages=[{"content": "Hello, how are you?", "role": "user"}])That example runs a local model through the same path as a hosted one, which is the point of sitting on top of litellm. The cost of that choice is visible in the pinned requirements file, which resolves to aiohttp, httpx, huggingface-hub, fsspec, filelock, certifi and a chain of small packages carrying python version markers, so a nine-line call arrives with a substantial dependency tree behind it. The other floor worth noting is pydantic, accepted anywhere from version 1 to 3, which is a wide range for a framework that leans on model validation.
Any Python function becomes a tool, and LangChain tools come along too
Two tool stories appear in the features list and they solve different problems. The first is that any Python function can be converted directly into a tool usable by agents, which removes the ceremony of declaring a schema and writing a wrapper for every helper you already have. The second is low-cost integration with tools from other frameworks, with LangChain named as the example, so an application that already accumulated LangChain tools does not have to rewrite them to move. The agent types are listed separately: WebAgent, ToolAgent and CodeAgent, each described as able to plan, reason and act on complex problems, with the further note that the planner and other components are atomized to simplify development. That word carries the design. An atomized planner is one you can replace, reorder or stub, which is what makes a one-function API survive contact with a real application, and it is also what makes the hook mechanism necessary rather than decorative. What the feature list does not give you is a mapping from task type to agent type, so choosing between a web agent and a code agent is a decision you make by reading the source rather than by reading a table. The example directory is where that decision gets made concrete, and its folder names describe real recipes rather than abstractions: a ToT folder, a chat-to-github-repo folder, building a math application with an agent, an ai-code-interpreter, an llmapper, a mem0 folder for a memory layer, an output_formatter, a util folder and a chat_usage notebook that shows how the call is metered. Two console scripts named pne and pne-chat point at different client modules, so the fuller client and the narrower chat path are both reachable.
Hooks and lifecycle management are the escape hatch the short API needs
If the public surface is one function, the extension points have to do the work of a larger API, and the features list names them. There is a wealth of hooks and comprehensive lifecycle management, allowing custom code to be inserted at various stages of agents, tools and large language models, which is the phrase to hold on to: the granularity is per component, not per call. Prompt caching is listed separately, offering a mechanism for caching large language model prompts to reduce repetitive work, and that is a feature worth evaluating on its own because cached prefixes are where the money is in a long agent loop. The terminal integration entry describes built-in client support for rapid debugging of prompts, which in practice means running a prompt in a terminal without assembling a session object first, and the example directory backs that up with dedicated llm, hook and tools folders. The last feature is Streamlit component integration, described as quick prototyping with out-of-the-box examples and reusable components, and the example folder contains streamlit-chatbot and streamlit-groq-llama3-chatbot alongside gradio-chatbot, wx-chatbot, mem0, llmapper and ai-code-interpreter. The Makefile confirms the split by naming separate test files for the model hook and the tool hook, so a change to one is not expected to cover the other. Prompt caching is the feature that pays for itself in a long agent loop, since the same instruction block is resent on every turn otherwise, and having it built in means you do not assemble a cache key and a storage layer yourself.
The Makefile names the real feature surface by listing its test files
The most informative document in the repository is not the README but the Makefile, because it enumerates what the project actually tests. The tool tests cover a human feedback tool, a calculator, a python repl tool, a sleep tool, arxiv tools, a tool manager and file tools. The hook tests are split into one for the large language model side and one for the tool side, which tells you hooks are treated as two distinct surfaces. The model tests are named for openai and for a factory, so there is a factory layer underneath the provider strings. The agent tests cover a tool agent and an assistant agent, and there is a beta test directory with a single file. The rest of the list is test_chat, the output formatter, an import test and a string template utility test. Two details in the same file are worth copying if you maintain a similar project. The Makefile detects the operating system and switches between a Windows branch and a POSIX branch, and the development command deliberately runs a smaller tests/basic target while the production command runs the full tests directory, so a fast local loop and a thorough one are different commands by design rather than by accident. The Makefile also sets the path variable per platform, using the current working directory on POSIX and an explicit set command on Windows, which is the minimum concession needed to run the same suite on both. Formatting is pinned through ruff with a line length of 88, and the same tooling set appears in the development dependency group.
Version 1.18.4 from 2024, a poetry lock, and a push in July 2026
The dependency and release picture is where an adopter should slow down. The project builds with poetry, the packaging metadata reads version 1.18.4, and the three most recent release tags are v1.18.2 in August 2024, v1.18.3 in September 2024 and v1.18.4 in October 2024, which is a steady monthly run that then stopped. The default branch was last pushed on 14 July 2026 and the repository is not archived, so work has continued on main without a release cutting it. The runtime dependency list is short and readable: litellm from 1.39.6, pydantic anywhere from 1 to 3, click, requests, questionary, python-dotenv, typing-extensions, broadcast-service and cushy-storage. Development tooling is pytest with coverage reporting and html output, pre-commit and ruff, and a separate integration group pulls langchain, arxiv, duckduckgo_search and pyjwt for the tests that reach outside the process. A poetry.lock is committed and a fully pinned requirements.txt sits next to it, so a reproducible environment is available even if the upstream version has moved on. Two installation routes sit alongside each other, the lock file for poetry users and the pinned file for everyone else, and the badges at the top of the page point at the PyPI project and a Telegram channel rather than at a documentation host, which suggests the community conversation happens outside the repository. The homepage is promptulate.cn.
Editorial conclusion
Adopt promptulate if you want an agent application in a few lines of Python, if you already use litellm-style provider strings, or if the terminal client and hook surface solve a specific annoyance in your current setup. The Python floor is low and the dependency list is short, so a trial is cheap. Do not adopt it as a framework to build a long-lived system on without reading the maintenance picture, because the latest release tag is from October 2024 while the default branch was last pushed on 14 July 2026, which means what you install and what the repository contains may not be the same thing. Four things to check first. Which version pip gives you, since the packaging metadata reads 1.18.4. Which litellm version you already pin, because the framework asks for 1.39.6 or newer and that floor moves. Which agent type you need, since WebAgent, ToolAgent and CodeAgent are separate things with separate tool surfaces. And whether the two console scripts, pne and pne-chat, do what you expect, because they point at different client modules.
Frequently asked questions
What is promptulate?
An AI agent application development framework from Cogit Lab, licensed Apache-2.0 and published on PyPI. Its stated idea is that you can build an agent application in a few lines of Python through a single call, pne.chat(), rather than learning a large framework vocabulary first.
Which AI providers does promptulate support?
It integrates litellm, so the provider strings are litellm's, and the README reproduces litellm's matrix of completion, streaming, async completion, async streaming, async embedding and async image generation across providers including openai, azure, aws bedrock, anthropic, mistral, groq, ollama, vllm, openrouter, huggingface and replicate.
How do you turn a function into a tool in promptulate?
The framework states that any Python function can be converted directly into a tool usable by agents, which removes the need to write a wrapper for every helper you already have. Tools from other frameworks can also be integrated at low cost, with LangChain named as the example.
What does the pne name stand for?
pne is the nickname for Promptulate: the p and the e are the first and last letters of the name, and the n stands for 9, a shorthand for the nine letters between them. The package installs as promptulate, and it provides two console scripts, pne and pne-chat.
Is promptulate still being released?
The newest release tags are v1.18.2, v1.18.3 and v1.18.4, published in August, September and October 2024, and the packaging metadata reads 1.18.4. The default branch was last pushed on 14 July 2026 and the repository is not archived, so commits have continued without a new release.
Official sources
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/undertone0809-promptulate)Star history chart for your README
[](https://hysenlabs.com/projects/undertone0809-promptulate)Was this useful?