u/Lower_Ad_5362

I work at a French AI company, and internally we’ve built our own agentic coding system for most of our software development.

We no longer use Claude Code, Codex, Cursor, OpenCode, etc. as our primary workflow.

It started as an internal experiment, but it has been a real game changer for us in terms of \*\*cost, efficiency, consistency and quality\*\*. We’re now considering turning it into an open-source project.

The core idea is pretty simple:

\*\*1. The system builds itself around your project\*\*

There is \*\*no universal agent configuration\*\*.

For an existing project, it audits the repository: architecture, stack, conventions, needs, permissions, risks, etc.

For a brand-new project, you can simply describe what you want to build, and it creates the initial architecture from that description.

From this, it generates a project-specific setup: agents, models, tools, MCPs, skills, permissions and routing.

And importantly, \*\*the configuration isn’t frozen after initialization\*\*.

As the project evolves, the system can re-evaluate its own setup and propose changes: adding or modifying agents, tools, skills, permissions or model routing as new needs appear.

So the agent system itself evolves with the codebase.

\*\*2. Frontier models think. Smaller models execute.\*\*

A frontier model acts as the \*\*orchestrator\*\*: it understands the request, plans, decomposes and dispatches the work — but doesn’t write the code itself.

Execution is handled by smaller models with focused responsibilities.

Every output then passes through deterministic gates — lint, types, tests, build — followed by an independent verifier.

If something fails, it goes back into the loop with new instructions. Complex cases can be escalated to a stronger Deep agent.

The idea is to spend expensive intelligence on \*\*reasoning and decisions\*\*, not on every token of execution.

\*\*3. It learns — without letting context grow forever\*\*

When something fails, the system can extract the cause and correction and reuse that lesson later.

If the same problem keeps appearing, the lesson can eventually become a \*\*lint rule, regression test, hook or other safeguard\*\*.

So instead of endlessly remembering \*“don’t make this mistake again”\*, the project eventually makes the mistake impossible.

We also built \*\*intelligent context compaction\*\*.

Context isn’t randomly summarized when the window fills up. Information is ranked by relevance and task state, important context can stay pinned, older validated context is compacted first, and everything compacted remains archived and recoverable.

So the goal is a system that improves not only its code, but also \*\*its configuration, memory and context management over time\*\*.

⸻

We’re seriously considering packaging this properly and releasing it as open source.

So I’m curious:

\*\*Would you actually try this?\*\*

Are you interested in experimenting with different agentic coding architectures, or are you already happy enough with Claude Code, Codex, Cursor or OpenCode that you wouldn’t bother?

If we released it, would you be interested in \*\*testing it, breaking it, contributing to it, or integrating it into your own workflow?\*\*

Trying to understand whether there’s real appetite for this before we take it further.

I work at a French AI company, and internally we’ve built our own agentic coding system for most of our software development.

We no longer use Claude Code, Codex, Cursor, OpenCode, etc. as our primary workflow.

It started as an internal experiment, but it has been a real game changer for us in terms of **cost, efficiency, consistency and quality**. We’re now considering turning it into an open-source project.

The core idea is pretty simple:

**1. The system builds itself around your project**

There is **no universal agent configuration**.

For an existing project, it audits the repository: architecture, stack, conventions, needs, permissions, risks, etc.

For a brand-new project, you can simply describe what you want to build, and it creates the initial architecture from that description.

From this, it generates a project-specific setup: agents, models, tools, MCPs, skills, permissions and routing.

And importantly, **the configuration isn’t frozen after initialization**.

As the project evolves, the system can re-evaluate its own setup and propose changes: adding or modifying agents, tools, skills, permissions or model routing as new needs appear.

So the agent system itself evolves with the codebase.

**2. Frontier models think. Smaller models execute.**

A frontier model acts as the **orchestrator**: it understands the request, plans, decomposes and dispatches the work — but doesn’t write the code itself.

Execution is handled by smaller models with focused responsibilities.

Every output then passes through deterministic gates — lint, types, tests, build — followed by an independent verifier.

If something fails, it goes back into the loop with new instructions. Complex cases can be escalated to a stronger Deep agent.

The idea is to spend expensive intelligence on **reasoning and decisions**, not on every token of execution.

**3. It learns — without letting context grow forever**

When something fails, the system can extract the cause and correction and reuse that lesson later.

If the same problem keeps appearing, the lesson can eventually become a **lint rule, regression test, hook or other safeguard**.

So instead of endlessly remembering *“don’t make this mistake again”*, the project eventually makes the mistake impossible.

We also built **intelligent context compaction**.

Context isn’t randomly summarized when the window fills up. Information is ranked by relevance and task state, important context can stay pinned, older validated context is compacted first, and everything compacted remains archived and recoverable.

So the goal is a system that improves not only its code, but also **its configuration, memory and context management over time**.

⸻

We’re seriously considering packaging this properly and releasing it as open source.

So I’m curious:

**Would you actually try this?**

Are you interested in experimenting with different agentic coding architectures, or are you already happy enough with Claude Code, Codex, Cursor or OpenCode that you wouldn’t bother?

If we released it, would you be interested in **testing it, breaking it, contributing to it, or integrating it into your own workflow?**

Trying to understand whether there’s real appetite for this before we take it further.

The problem. We work on AI tutoring. Two students can need genuinely opposite interventions on the same exercise — one needs to be slowed down before he applies a method, another needs the pressure removed before anything else.

We first tried to solve with the standard toolkit: system prompts, in-context data management, RAG over student history, LoRA and other PEFT adapters. All of it moves the surface — tone, register, phrasing — none of it moved the pedagogy underneath. Same reasoning path, same strategy, different wrapping: adapted in form, generic in substance.

Our approach. We keep the base model frozen and modulate its internal computation at inference from a learned latent state — no prompt injection, no fine-tuning per user, no context consumed. The goal is to shift how the model reasons, not what it says.

On top of that, the architecture is built so that the latent state is learned from interaction history and updated from observed effects — not from stored transcripts or retrieved conversation logs. The distinction matters: memory-based approaches replay what happened, this learns what worked and adapts accordingly over time.

Setup. Qwen3-8B, frozen.

Three target profiles with very different behavioral requirements,

20 math questions each. Two conditions:

base model alone vs. base model + modulation. Identical prompt in both — no system prompt, no profile description, no few-shot. Blind LLM judge, 6 behavioral criteria per profile, scored /10.

The gain scales with how far a profile sits from default model behavior — the harder a profile is to pin down and adapt to, the more the approach delivers.

Why this isn’t just an edtech thing. Nothing in the mechanism is education-specific.

Any domain where the right answer depends on the path taken to reach it, and where that path should differ by user, context or ta sk, is a candidate — software engineering (verification habits before shipping), clinical decision support (which hypotheses get held open), finance, and others.

Same frozen base model, swappable policies at inference.

I would love to hear what you guys think about that.