Agentic Culture

Andrej Karpathy shared on the Dwarkesh Podcast that LLMs don't have the equivalent of "culture".

So we built the scaffolding for them to develop one.

Why Culture?

Every Agent learns from its own interactions — the tasks it runs, the conversations it has, the errors it fixes. But that knowledge is siloed. It disappears when the session ends or the user changes.

Humans solved this problem a long time ago. We call it culture — the consolidation of shared knowledge that compounds over time.

With Agno, you can now give your Agents the same ability to learn collectively.

Introducing Agentic Culture

Agentic Culture is an open-source experiment in collective memory and in-context cultural for multi-agent systems.

It provides a shared cultural database where Agents can store and retrieve knowledge that persists beyond individual sessions, users, or memories. Culture becomes a living, evolving layer of context that shapes Agent reasoning and behavior over time.

Agents can now create, read, explore, and learn from their collective experience. See the Agentic Culture cookbook for example code.

“Culture is how intelligence compounds”

How It Works

Culture acts as a shared database where Agents can save reusable knowledge that benefits all interactions.

While Memory captures user-specific details (e.g. "Sarah prefers email"), Culture captures universal principles that benefit all interactions (e.g. "Always provide actionable next steps").

You can use Agno’s CultureManager to create and manage cultural knowledge entries. These are stored in your chosen database and automatically retrieved by your Agents for contextual grounding.

"""Demonstrates how to create and persist shared cultural knowledge with Agno's `CultureManager`."""

from agno.culture.manager import CultureManager
from agno.db.sqlite import SqliteDb
from agno.models.anthropic import Claude
from rich.pretty import pprint

# Step 1. Initialize the database
db = SqliteDb(db_file="tmp/demo.db")

# Step 2. Create the Culture Manager
culture_manager = CultureManager(
    db=db,
    model=Claude(id="claude-sonnet-4-5"),
)

# Step 3. Create cultural knowledge from a message
message = (
    "All technical guidance should follow the 'Operational Thinking' principle:\n"
    "1. **State the Objective** — What outcome are we trying to achieve and why.\n"
    "2. **Show the Procedure** — List clear, reproducible steps (commands/configs).\n"
    "3. **Surface Pitfalls** — What usually fails and how to detect it early.\n"
    "4. **Define Validation** — How to confirm it’s working (logs, tests, metrics).\n"
    "5. **Close the Loop** — Suggest next iterations or improvements."
)

culture_manager.create_cultural_knowledge(message=message)

# Step 4. Retrieve and inspect stored knowledge
pprint(culture_manager.get_all_knowledge())

Now give your agents access to the shared culture by setting add_culture_to_context=True. That's it. Your Agents now learn from shared cultural knowledge.

"""Use cultural knowledge with your Agents."""

from agno.agent import Agent
from agno.db.sqlite import SqliteDb
from agno.models.anthropic import Claude

db = SqliteDb(db_file="tmp/demo.db")

agent = Agent(
    model=Claude(id="claude-sonnet-4-5"),
    db=db,
    add_culture_to_context=True,
    # optional: run culture manager after each run
    # update_cultural_knowledge=True,
)

agent.print_response(
    "How do I set up a FastAPI service using Docker?",
    stream=True,
    markdown=True,
)

What You Can Do With It

The current v0.1 release focuses on helping Agents stay consistent in tone, reasoning, and behavior. Over time, the goal is to transform isolated Agents into a living, evolving system of intelligence.

With Culture, you can:

  • Accumulate learnings and behavioral patterns from successful runs
  • Use that collective context to guide future decisions
  • Observe how "culture" evolves across teams, orgs, and domains

Examples

The Agentic Culture cookbook includes several runnable recipes:

FileDescription
01_create_cultural_knowledge.pyCreate cultural knowledge using a model.
02_use_cultural_knowledge_in_agent.pyUse cultural knowledge inside Agents.
03_automatic_cultural_management.pyLet Agents autonomously update culture over time.
04_manually_add_culture.pyManually seed culture for tone guides or org-wide principles.
05_test_agent_with_cultural_knowledge.pyFreestyle testing — see culture in action.

Each builds on the previous one, so you can run them in sequence.

Agno is open-source, so you can contribute to the cookbook or build your own recipes. Here's the github repository: agno.link/gh

Future Work

This is early, but promising. We're exploring how to:

  • Integrate culture across multi-agent teams.
  • Sync or version cultural knowledge programmatically
  • Store culture in Postgres, Redis, or your own backend
  • Let Agents evolve shared norms collectively, like emergent civilizations

Karpathy describes a future where LLMs have a "giant scratchpad" — a shared space to think, write, and build on each other's ideas.

Agno is providing the scaffolding for developing that culture.

Explore & Build