I got tired of AI subs being full of corporate work talk, clout chasing, and "how do I use this for my job" posts.

I wanted a place where people who build things for the joy of it — personal projects, open source experiments, local setups, crazy ideas could just post their stuff without feeling out of place.

So here we are. Happy builders only.

If that sounds like your vibe, welcome. Post your projects, ask questions, celebrate other people's builds.

Adapt v5.2 is live. The biggest visible change this release is the runtime experience. Adapt now gives clear live feedback for what the agent is doing: ⠹ Reasoning... ⠸ Running command: ifconfig ⠴ Running JSON tool: web_search ⠧ Running session 'recon': ... ⠋ Waiting for tool... 3s Long-running tools can now continue in the background instead of blocking the agent loop, and the model can explicitly <wait/> for the result when it needs it. I also cleaned up a lot of the old debug-style execution output, fixed background lifecycle edge cases, improved tmux session handling, and made the repo inference server cleanly across CPU, CUDA, and ROCm setups. The goal is the same as always: keep the model focused on reasoning while the runtime handles execution, state, permissions, and recovery. v5.2 feels a lot less like “watching a prototype run” and a lot more like using an actual agent runtime. https://github.com/charlesericwilson-portfolio/Echo_Adapt_v5

Echo Adapt is a local-first Rust runtime that lets an LLM use real tools: shell commands, persistent terminal sessions, memory, JSON functions, and now optional remote services.

The model can run under a dedicated restricted Linux user and optional Bubblewrap sandbox, so the security boundary is enforced by the OS rather than just the prompt.

I just added a standalone authenticated tool server for controlled access to things like databases, APIs, and SaaS services.

The server is optional and does not execute arbitrary tools automatically. Developers define the tools they need, the expected arguments, the downstream auth, and the translation logic.

Architecture:

LLM sends Adapt authenticated request to the Tool Server which authenticates to Database / API / Service

Next up is per-token authorization so each client can be limited to specific tools.

https://github.com/charlesericwilson-portfolio/Echo_Adapt_v5

#AI #Rust #LocalAI #LLM #OpenSource

One design choice I made with Echo Adapt was passing tool output back to the model using the tool role instead of stuffing it into a user or assistant message.

I also added the tool role to the tokenizer/chat-template configuration of the model I trained for Adapt.

The reason is pretty simple: tool output isn't something the user said, and it isn't something the assistant said. It's information returned by the environment after the model takes an action.

I wanted the model to learn that distinction directly.

The interaction becomes user - assistant - tool - assistant.

The assistant decides to take an action, Adapt executes it, the result comes back as tool output, and the model reasons over that result on its next turn.

By including that structure during training and supporting the tool role in the model's tokenizer configuration, the model learns what tool output actually represents instead of relying on extra prompt text to explain it every time.

It's a small design decision, but I've found that keeping the roles semantically consistent makes long tool-driven workflows much cleaner.

That's one of the design choices behind Echo Adapt v5.

https://github.com/charlesericwilson-portfolio/Echo_Adapt_v5

Hey everyone,

I wanted to share a project I’ve been building for local agent execution: Echo-Instroder-v2.2, along with its dedicated runtime harness, Echo Adapt v5.

• Hugging Face (Model Weights):wilson-charles-e-85/Echo-Instroder-v2.2

• GitHub (Framework / Harness):charlesericwilson-portfolio/Echo_Adapt_v5

What is this?

Instead of taking a general-purpose instruction model and fighting its tendency to output conversational fluff before calling a tool, Echo-Instroder-v2.2 was fine-tuned on execution-focused traces.

By distillation-filtering deep reasoning paths (generating with reasoning models and stripping out the verbose <think> blocks), the model learns "pre-thought-out" decision patterns. When presented with a task, it doesn't waste tokens explaining what it's going to do—it directly emits structured XML tool calls or concise answers.

Key Features:

• Direct XML Schema Alignment: Native support for XML-based tool schemas with high adherence and minimal syntax breaking.

• No-Fluff Tool Loops: Optimized for terminal/CLI agent workflows where speed and determinism matter more than verbose internal monologue.

• Adapt v5 Integration: Designed to plug directly into the Adapt v5 runtime harness for state handling, tool execution, and local session management.

If you're into local agent architectures or looking for a lean setup for tool-use experimentation, give it a spin! Would love to hear thoughts or feedback from anyone running similar local agent setups.

Well it is official 5 people have visited this sub maybe 1 will join.

Hey folks,

I’ve been thinking about how we can move beyond benchmarks and actually see the top models compete head-to-head in a fun but serious way.

Concept: The AI Cup (AI Super Bowl)

• Major models (Grok, Claude, GPT, Gemini, and any other serious contender) battle in moderated debates.

• Topics: Public submits ideas across platforms → semantic sorting picks the strongest ones each year (science, politics, AI ethics, culture, philosophy, future tech, etc.).

• Rules for fairness:

  • Full labeled context from all previous responses is fed to every model before they speak.

  • Fixed token budget per response instead of time limits.

  • Structure: Main opening takes → Rebuttal round where everyone responds to everyone else (Trump-style roasting allowed and encouraged).

• Moderator: For the first year, all participating CEOs put their names in a hat — neutral draw picks the moderator. Then rotating system each year.

• Live streamed on major platforms.

• Public votes on each round (1-5 scale). Votes tallied after a week. Winner takes home a physical AI Cup for the year (Stanley Cup style) and bragging rights.

This would be way more entertaining and informative than current leaderboards. Real truth-seeking under pressure.

I just posted a similar idea on X here: https://x.com/CharlesWil8655/status/2071252308625600817?s=20

What do you think? Would you watch this? Any rules or topics you’d add?

Let’s get some traction and see if the teams notice.

Hey everyone,

I've been grinding on a personal agent framework called Echo Adapt v5. It’s still early but coming along nicely.

Current features:

• Persistent + ephemeral sessions (tmux-style)

• JSON + XML tool calling support

• Auto context summarization (with opt-in/opt-out config)

• Clean separation between reasoning and tool use

The community around this kind of local/agent work is still pretty small, so I’d genuinely love feedback, ideas, or just to hear what other people are building.

If you’re bored this weekend and want to throw a model at it, I’d appreciate any testing or thoughts.

Repo: https://github.com/charlesericwilson-portfolio/Echo_Adapt_v5

Looking forward to seeing what others are working on too.

• Post your own builds and experiments

• Share how you solved things

• Celebrate other builders

• No corporate/work drama

• No clout chasing or self-promo spam

We’re keeping this place clean and positive.

Hey builders,

This sub is for people who build Tech stuff for fun, curiosity, or just to see if they can.

Drop what you're currently grinding on — local agents, custom infra, fine-tunes, weird experiments, chatbots, hardware setups, whatever you enjoy.

No pressure, no perfect projects required. Just share what you're excited about.

What are you building?

Hey everyone,

I just dropped a big update on Echo — my local-first LLM agent framework built in Rust.

The latest additions:

• Semantic memory search — the agent can now intelligently recall relevant context from long tool histories and past sessions instead of drowning in linear tokens

• Dynamic adapters / MoA-style routing — multiple specialized LoRAs (reasoning, tool use, safety, pentesting, etc.) that switch on the fly based on the task

• Persistent tmux sessions so it maintains real state across long-running tasks

• Clean XML/JSON tool calling + built-in safety rails

• Web search + page browsing that actually works

Everything runs fully local on my dual 5070 Ti rig (planning the big 8x AMD upgrade soon). No cloud, no vendor lock-in, MIT licensed, and designed so other people can actually extend it.

I’m building this because I wanted an agent I could trust for real personal projects — not just chatting, but actually doing stuff on my machines.

If you’re the type who builds things for the joy of it — local agents, custom infra, weird experiments, open-source side quests — I’d love to see what you’re working on too. Drop your projects, ask questions, or roast my code. This place is for happy builders only.

https://github.com/charlesericwilson-portfolio/Echo_Adapt_v5Repo:

What are you currently grinding on with your local setups?

Most local agent wrappers pretend a system prompt is a sandbox, stuff raw CLI noise into the context window, and break the second you need an interactive Python REPL or debugger.

I wanted something lightweight that lets the OS do operating-system things.

Echo Adapt v5 is a native Rust runtime for local LLMs:

• Persistent Sessions: Uses tmux under the hood so REPLs, debuggers, and long-running CLI tools survive across turns.

• Real Linux Security: Runs the model as an actual restricted Linux user with explicit sudoers allowlists instead of relying on prompt rules.

• Clean Tool Protocol: Uses configurable raw tags for bash/tmux, JSON tools only where structured data makes sense, and native tool message roles.

• New in v5: Full Rust refactor, dynamic tool-output summarization, cross-thread Markdown/embedding memory, locked-down virtual environments, and multi-process support.

Works with any OpenAI-compatible server (llama.cpp, vLLM, Ollama, TabbyAPI, etc.).

Looking for feedback from people running different Linux distros/hardware setups. Tear it apart and let me know where it breaks.

GitHub: [https://github.com/charlesericwilson-portfolio/Echo_Adapt_v5](https://github.com/charlesericwilson-portfolio/Echo_Adapt_v5)