Every AI coding agent ships with baked-in behavior. Hidden system prompts you can't see. Tools you can't remove. Steering baked in by the company that made it.

It's just how these products work. Batteries included.

Claude Code has a system prompt. A long one. It tells the agent how to behave, what to prioritize, what to avoid. It's not exposed in the product. You can dig it out of the npm package if you know where to look, but you can't change it. Cursor has tool definitions and behavior rules that shape every interaction. Copilot has its own set of baked-in instructions.

And these prompts are good. They're written by smart people who understand the model. They make the agent useful out of the box.

But they're not yours.

The Problem with Baked-In Behavior

I think we've all been there. The agent does something weird and you don't know why. Was it your prompt? Something you can't see? A tool description that's steering the model in a direction you didn't ask for?

You're debugging a black box.

Here's what actually happens:

You can't debug behavior. The agent does something unexpected and you have no way to trace it back to the instruction that caused it.
Your prompts fight theirs. You say "always use pnpm" and it uses npm anyway. Why? Because somewhere in the baked-in prompt, something overrides your preference in certain contexts. You can't find the conflict because you can't see the other instruction.
You can't remove behavior you don't want. Maybe you don't want it to run tests after every change. Maybe you don't want commit suggestions. If it's baked in, you're stuck.
You can't tell what's the model and what's the product. Did the agent recommend that library because it's good, or because a baked-in instruction told it to? You can't distinguish model knowledge from product steering.

What Jean2 Does Differently

Jean2 ships with no default system prompt. No default tools. No fixed agent personality.

The binary is blank by design. When you start a session, the system prompt is composed from pieces you control. Let me walk through each piece.

Preconfig Prompts

A preconfig is a saved agent configuration: model, tools, prompt, skills. The system prompt in a preconfig is the core prompt for that agent. You write it. You see it. You change it.

No hidden instructions. What you write is what the agent gets.

Workspace Instructions (AGENTS.md)

Every workspace can have an AGENTS.md file at its root. Project-specific instructions, included in the system prompt automatically:

# AGENTS.md

## Build Commands
- `bun run build`: build all packages
- `bun run test`: run all tests

## Code Style
- Use `import type` for type-only imports
- 2-space indentation
- Single quotes for strings

## Don't
- Don't modify packages/sdk/src/version.ts without updating the version
- Don't run the server without asking first

It's version-controlled with your code. Anyone on your team gets the same instructions.

Workspace Memory

The workspace MEMORY.md. Facts the agent learned and saved. "We use pnpm", "the database is SQLite", "tests run with bun:test". Tell it once, it writes it down, it knows forever.

Agent Memory

Your personal agent memory. USER.md and MEMORY.md from the agent's home directory. Preferences and knowledge that travel with the agent across projects.

Skills

Any skills the agent loads. Skills are playbooks: deployment checklists, code review standards, debugging workflows. Written by the agent, or by you.

The Full Composition

Here's what the prompt assembly actually looks like:

[Preconfig System Prompt]
  ↓
+ [AGENTS.md from workspace root]
  ↓
+ [Workspace MEMORY.md]
  ↓
+ [Agent USER.md + MEMORY.md]
  ↓
+ [Loaded Skills]
  ↓
+ [Session Search guidance + Skill management guidance]
  ↓
= Final System Prompt sent to LLM

Every piece is a file on disk. Readable, editable, version-controllable. No hidden layers.

Why This Matters in Practice

Let me give you a concrete example. I was using a coding agent (not Jean2) and it kept adding console.log statements to debug code. Every session, same thing. I'd tell it not to, it would agree, and 20 minutes later there's another console.log in my codebase.

I couldn't fix it because I couldn't see what was causing it.

With Jean2, if the agent does something I don't want, I can:

Check the prompt. Is there something in my preconfig or AGENTS.md that's ambiguous?
Add a rule. Write it to memory: "Never add console.log for debugging. Use the debugger or write proper tests."
Create a skill. If it's a repeating pattern, make a "Debugging Standards" skill with specific steps.
Verify it's working. The next session, check if the rule is in the prompt. It is. I can see it.

With a baked-in agent, you can't do step 1. You can't see the prompt. You're guessing.

The Counterargument

Here's the fair pushback: most people don't want to write system prompts. They want an agent that works out of the box.

True. That's where preconfigs come in. A preconfig is a starting point. You can create one for coding, for research, for review. Someone can share a preconfig. A team can maintain a standard set.

The difference is that the preconfig is visible and replaceable. You can see exactly what instructions the agent has. Change any of them. Throw the whole thing out and start from scratch.

Baked-in means you can't. Preconfigs mean you can.

The Transparency Test

Here's a simple test. Ask your current AI agent:

"What's in your system prompt? What instructions are you operating under right now?"

Some will refuse to answer. Some will give a vague summary. Some will hallucinate. Almost none will show you the actual prompt.

In Jean2, the answer is: check the files. It's all files on disk. You can read every word. Diff it between versions. Share it with your team.

What's Next

Jean2's approach isn't for everyone. If you want a turnkey coding agent that works perfectly the moment you install it, with zero configuration, Jean2 isn't that. Yet.

But if you've ever been frustrated by an AI agent doing something you can't explain, can't debug, and can't change, Jean2 is built for you.

Every layer is yours. Every prompt is visible. Every behavior is configurable. No company can switch off a feature because of your region. There's no server to enforce from and no telemetry to check with. Your tools on your computer should be yours.

Try it out or join the Discord. I'm @danielbilekq0 if you want to argue about it.