To make this practical, I turned the workflow into agentic skills: init specs, validate constraints, generate history, enforce consistency.
I put them here: https://t.co/7tM5MOA8HG
If you’re building something complex, this method worth trying. It changes how AI coding feels.
To make this practical, I turned the workflow into agentic skills: init specs, validate constraints, generate history, enforce consistency.
I put them here: https://t.co/7tM5MOA8HG
If you’re building something complex, this method worth trying. It changes how AI coding feels.
To make this practical, I turned the workflow into agentic skills: init specs, validate constraints, generate history, enforce consistency.
I put them here: https://t.co/7tM5MOA8HG
If you’re building something complex, this method worth trying. It changes how AI coding feels.
I built Grism, an AI-native, neurosymbolic hypergraph database in modern design, from concept to working prototype in THREE days. Honestly, I didn’t expect it to move that fast for something this complex.
https://t.co/bHUl2JCSgG
What changed next was how I worked with agents. I stopped explaining intent and started referencing structure. Conversations became about invariants, definitions, and allowed changes. When specs are explicit, agents don’t guess. They operate inside a shared world.
8 AI model architectures, visually explained:
Everyone talks about LLMs, but there's a whole family of specialized models doing incredible things.
Here's a quick breakdown:
1. LLM (Large Language Models)
Text goes in, gets tokenized into embeddings, processed through transformers, and text comes out.
↳ GPT, Claude, Gemini, Llama.
2. LCM (Large Concept Models)
Works at the concept level, not tokens. Input is segmented into sentences, passed through SONAR embeddings, and then uses diffusion before output.
↳ Meta's LCM is the pioneer.
3. LAM (Large Action Models)
Turns intent into action. Input flows through perception, intent recognition, task breakdown, then action planning with memory before executing.
↳ Rabbit R1, Microsoft UFO, Claude Computer Use.
4. MoE (Mixture of Experts)
A router decides which specialized "experts" handle your query. Only relevant experts activate. Results go through selection and processing.
↳ Mixtral, GPT-4, DeepSeek.
5. VLM (Vision-Language Models)
Images pass through a vision encoder, text through a text encoder. Both fuse in a multimodal processor, then a language model generates output.
↳ GPT-4V, Gemini Pro Vision, LLaVA.
6. SLM (Small Language Models)
LLMs optimized for edge devices. Compact tokenization, efficient transformers, and quantization for local deployment.
↳ Phi-3, Gemma, Mistral 7B, Llama 3.2 1B.
7. MLM (Masked Language Models)
Tokens get masked, converted to embeddings, then processed bidirectionally to predict hidden words.
↳ BERT, RoBERTa, DeBERTa power search and sentiment analysis.
8. SAM (Segment Anything Models)
Prompts and images go through separate encoders, feed into a mask decoder to produce pixel-perfect segmentation.
↳ Meta's SAM powers photo editing, medical imaging, and autonomous vehicles.
What else would you add?
👉 In my next tweet, I have shared my latest AI Engineering Guidebook (380+ pages) with 150+ core lessons.
Everything is 100% open-source (25k+ stars 🌟)
🚀 **cogents-core v1.0.0 is now stable!**
A comprehensive cognitive agentic framework for building intelligent multi-agent systems.
✨ Features:
• Multi-LLM support (OpenAI, Ollama, LiteLLM, etc.)
• DAG-based goal management (Goalith)
• Tool orchestration with MCP and more
What can we learn from Anthropic’s Blog about building tools for Agents? Here are the key principles I extracted for building Tools and MCP Servers for Agents:
- Consolidate workflows: Implement `schedule_event` instead of separate `list_users`, `get_availability`, and `create_event` tools.
- Evaluate with real tasks: Test with goals like "find the project lead and schedule a meeting," not just "get user."
- Automate metrics: Programmatically run evaluations to track success rates, token counts, and tool call frequency.
- Let AI refactor: Feed failed evaluation transcripts to an LLM to get suggestions for improving your tool's code.
- Namespace tools clearly: Use prefixes to differentiate tools, such as `jira_search_issues` vs. `github_search_issues`.
- Return meaningful context: Prefer human-readable names like "Jane Doe" instead of cryptic `usr_7a3b4c9` IDs.
- Enforce token efficiency: Implement pagination and filtering for tools that can return long lists of results.
- Make errors helpful: Instead of `Invalid input`, return `Error: Missing 'user_id'. Example: search(user_id=12345)`.
- Guide with messages: If output is cut, guide with "Showing 10 of 100 results. Use the 'page' parameter for more."
- Use unambiguous parameter names: Use `user_email` or `user_id` instead of a generic `user` parameter.
- Define formats explicitly: In parameter descriptions, specify requirements like "Date must be in YYYY-MM-DD format."
- Provide examples in descriptions: Add an `Example: search_query='status:open'` to the parameter's help text.
When you are a programmer who want to switch AI tools from different vendors, but meanwhile remain your work progress. the best method is to use a vendor agnostic configuration. if you have the same problem you can try dotaidev project