Introducing Standard Agent: Composable Core Code for Agents

LLMs are hard. Tooling is hard. But the glue that sticks them together (commonly known as “agents’) is actually pretty simple.

In Jentic we’re squarely over on the tooling side of the equation, providing a capability backend for business agents. But to reliably test and evolve our platform, we needed to build a flexible agent; one that is legible, composable, testable, hackable, and fit for experimentation.

TL;DR

Today, we’re open-sourcing Standard Agent, the tiny Python library that underpins all our internal agents. It’s less than 1000 lines of core code, doesn’t try to be magic, and is ready for you to clone, fork, extend, or replace.

It's Arrived

So here it is, and like we said, it wasn’t even that hard.

Today, we’re open-sourcing Standard Agent, the tiny Python library that underpins all our internal agents. It’s less than 1000 lines of core code, doesn’t try to be magic, and is ready for you to clone, fork, extend, or replace.

Technically, it’s a library, not a framework. You call it; it doesn’t call you. You don’t need to learn new concepts or think in a new way. It’s the code you’d write yourself, except now you don’t have to.

Why We Built This

Jentic works with all kinds of agents - anything that can speak MCP or HTTP. But we still need our own agents to test things, to use our API catalog, solve novel API workflows, validate real-world integrations and generally dog-food our work.

We think most agent frameworks are too complex. You can actually code an agent in plain python in a few hundred lines of code, or even get your AI to do it for you. In fact, if standard agent merely encourages you to roll your own, we’ll consider that a victory.

But it’s also useful to have simple shared codebases where we can collaborate as a community and push the frontier forward together. Standard Agent is fit for that purpose: small enough (824 lines of python as of this writing!) that you can read the whole thing over one cup of coffee, flexible enough to feel it’s your own, and standard enough that you can easily share whatever advancements you make.

We’re using it internally for testing, automation and mining novel API workflows to expand the capabilities of our public catalog of OpenAPI and Arazzo workflows. Soon, you’ll be able to run a hosted agent on our platform and - guess what - that will just be instances of Standard Agent under the hood.

What It Is (and Isn’t)

Less is more, and we’d like to keep it that way. We want this to be plain and simple, with no new jargon, acronyms or abstract metaphors. Standard Agent is not intended as an out-of-the-box agent for end-users, and we haven’t spent time (yet) on any quality UX or useful filesystem tools. We hope to see all those layered on by other projects that leverage Standard Agent for their core reasoning loop.

What you will find inside Standard Agent is just the parts you need to:

• Run reasoning loops (ReAct and ReWOO today, more coming)
• Interface with any LLM
• Wire up tools and toolchains (e.g., whether through Jentic or your own custom tools)
• Manage memory (basic dict, Redis, or anything with a MutableMapping python interface)

Every class is small. Every file is readable. It’s Cursor/Claude-friendly. If you want to build a custom agent loop, you can. If you want to plug in a different reasoner or memory backend, it’ll take you minutes.

Simplicity is Clarity

Big frameworks introduce hidden failure modes and get in the way of full-stack thinking. Getting an agent running shouldn't require divine insight or running out of credits when you’re still vibecoding at 2AM.

With Standard Agent, there’s no black box. No magic. It’s probably faster to read the code than the docs.

It especially shines when paired with the Just-in-Time tooling paradigm, which we recommend (we’ve helpfully included Jentic as a tool provider in the library for you). When you build this way, you can quickly create a general-purpose agent that is little more than:

• A prompt (your choice)
• A loop and some glue logic (that’s where Standard Agent comes in)
• A tool catalog (e.g., Jentic)

Try It, Fork It, Extend It

You can:

• Spin up a working ReAct or ReWOO agent in minutes
• Swap in your own reasoner by subclassing BaseReasoner
• Integrate with any tool: Everything in Jentic, but also MCPs, local scripts, remote APIs
• Drop in your own LLM, vector store, or memory system

We’ve deliberately kept the interface surface small and the abstractions thin. Want to experiment with Plan-Act? LATS? Model routing? Do it (and then please do a PR). This is the foundation, not the ceiling.

Why We’re Giving It Away

We want to demystify how agents actually work and help bring forward an era where the agent code isn’t seen as the hard part. We believe that powerful general purpose agents will soon be commoditized, and that we will all be launching them as frequently as we create new google sheets today. That’s a good future for all of us. We hope this small contribution helps usher in that future.

If you’re a developer, it’s yours to fork, read, modify, run, copy - whatever floats your boat.

If you’re a researcher, it gives you a common base for building reference agent implementations, providing ease of comparison and controlled testing and benchmarking.

If you’re building business agents on Jentic, this is what Jentic’s native hosted agent runs under the hood.

The Bigger Picture

This release is part of our broader commitment to open infrastructure for agents:

• jentic-public-apis: a growing catalog of 1500+ OpenAPI specs and 2000+ Arazzo API-based workflows for agents
• Hosted execution and auth: secure, managed tool execution, including atomic workflow execution
• Hosted agents (beta): run your own agents inside Jentic, no coding required.

We’re building the connective layer of agentic software. And we’re making sure the core is open.

Get Involved

Start here: https://github.com/jentic/Standard Agent

Then:

• Star the repo
• Run the examples
• Join our Discord
• Build your own reasoners, tools, or memory modules
• Contribute back, if you’d like

Let’s keep agents open, simple, and composable. That’s what they were meant to be.