Pinned Tweet
About This Page
I publish work across three surfaces. They’re all part of the same architecture, but each one speaks to a different layer.
lintel scent
Short notes from the governance layer — admissibility, the Motion Harness, and the RDA surface.
lintel signal
Constraint-level observations as the architecture stabilizes — the boundary conditions, the invariants, the patterns.
lintel geometry
The execution layer — deterministic, fixed-width, microarchitecture-aligned work for robotics, aerospace, and embedded systems.
This pinned post is the map.
Everything else in the feed is a surface.
Lintel Scent / Preserving Meaning Without Forcing Certainty
“You were never indecisive. You just didn’t want to lie.”
That thought may resonate. But seeing someone hesitate doesn’t tell us why they hesitated. They may be uncertain, weighing competing priorities, or unwilling to say something they cannot stand behind.
“I haven’t chosen,” “I cannot choose,” and “I’m not sure yet” carry different meanings. When we substitute one for another, we add an interpretation the person may never have expressed.
Semantic state formation preserves those distinctions. It captures what someone says, keeps their qualifications intact, and leaves unresolved meaning open. If they explain their reason, we can preserve it as their account.
“I don’t know yet” is already meaningful. A good clarifying question makes room for that answer.
Pressure for an answer isn’t evidence for one.
2
29
One letter can change an entire assertion:
“I am not taking the medication.”
“I am now taking the medication.”
Negation becomes timing.
Capturing words faithfully doesn’t guarantee we’ve captured intent.
Human demand conformance checks that the meaning formed matches what the person meant.
Pressure for an answer isn’t evidence for one.
1
2
Even a single word substitution, like “now” for “not”, can change an assertion completely. Faithfully capturing someone’s words doesn’t guarantee we’ve captured their intent. That’s why we need human demand conformance: checking that the meaning we formed matches what the person meant, with consequential ambiguity left unresolved until clarified.
14
Why be a VW Beetle when you’re actually a Porsche?
Forward deployed engineer is a stupid job title!
Are we in the military deploying the troops to build AI agents?
You’re a solutions architect who knows how to prompt Claude. Don’t let the propaganda from Palantir get to your head.
Some of you aren’t even solutions architects. You’re consultants pretending to be more important than you actually are!
Can we please go back to job titles that actually describe the work that is being done and not some weird pseudo-militaristic hype that we are all swallowing right now?
2
45
billyflynt retweeted
With yesterday's elections results there is now no doubt that Local AI is the only way forward
billyflynt retweeted
Sperax built a custom MCP server so Sperax runs right inside @ChatGPT. Our custom Plugin gives @OpenAI and ChatGPT crypto tools built on the same engine as SperaxOS.
MCP, the Model Context Protocol, is the open standard that lets an AI assistant use outside tools and live data. Without it, ChatGPT can only answer from what it already knows. With it, ChatGPT can call our tools in the middle of a conversation and show you the results as cards and charts.
Here's what's inside, how to add it today and what comes next 🧵
Sperax is officially an OpenAI Partner.
Seven years after Sperax started building onchain money, our AI agent workspace for crypto and DeFi has joined the OpenAI Partner Network at the Select tier.
The video shows what that looks like today. This is the Sperax Trading Desk running inside ChatGPT. Ask it in plain English and it checks a token for rug risk, compares swap quotes across numerous providers, stress tests a portfolio against past crashes and backtests a strategy on real candles. It has 43 read-only tools, and nothing in it signs a transaction or moves money.
AI agents are starting to hold, move and pay with money. OpenAI builds the brain. SperaxOS is the workspace, with real data, real tools and real guardrails around real money. Sperax USDs, paid over the x402 protocol, is the wallet and the currency.
Here's what the partnership means, what's live today and where we're going 🧵
Cohesion is the moat.
The last mile is where the product, integrations and actual workflow have to hold together for the person using them.
Keeping that whole experience reliable as things change is the hard part.
2
95
Transform.
Replying to @tryharness
@tryharness and @t3dotcodes have become pretty much transformed my entire workflow these days when it comes to working with agents.
@tryharness sits at the top, letting me orchestrate high level goals across all the agents across all the devices in my house, all connected to each other via my local network. And lets me quickly check in on, steer, or organize tasks.
T3 code is the environment in which i use to get deep work done, putting together mockups, reviewing code, writing scaffolds, types, and function patterns.
Its been truly transformative.
Check out this video on some of the things you can do with a swarm.
1
66
Who Is Qualified to Decide?
We're working to close a gap that exists in both enterprise systems and autonomous systems.
Part of that effort involves separating concerns that have historically been collapsed together.
Today we commonly model:
Identity
Authority
Role
Capability
Permission
Those are important.
But consequential decisions are rarely made using those factors alone.
Humans also rely on:
Qualification
Experience
Competence
Judgment
Demonstrated Performance
Talent
In other words:
May act
≠
Should evaluate
A hospital already understands this.
A licensed surgeon may be authorized.
A specialist may be qualified.
A resident may be capable.
A highly talented clinician may recognize a condition others miss.
None of those are interchangeable.
Yet many systems still collapse them together.
As autonomous systems evolve, I suspect we'll need to become much better at separating them.
Now let's move that forward.
Suppose a participant has:
Authority Provenance = Valid
Role Assignment = Valid
Capability = Present
but:
Qualification Evidence = Weak
Or:
Qualification = Valid
Demonstrated Talent = Exceptional
Authority = Absent
Should the system proceed?
Should it refuse?
Should it escalate?
Should it require additional review?
That's no longer an authorization question.
It's a competence question.
And I suspect it may become one of the defining challenges of autonomous systems.
The interesting part is that this problem isn't exclusive to AI.
A participant could be:
Human
Service
Agent
Model
Controller
Worker
The underlying question remains the same:
How does a system distinguish between being authorized, capable, qualified, talented, and admissible?
One possible answer is to stop treating qualification as authority.
Instead, treat qualification as evidence.
Evidence of training.
Evidence of experience.
Evidence of demonstrated performance.
Evidence of successful evaluation.
Evidence that a participant, human or otherwise, is qualified to evaluate a particular subject.
Perhaps the future model looks something like:
Authority
determines
who may participate
Qualification
is established
through evidence
Talent
influences
confidence in evaluation
Admissibility
determines
whether execution may proceed
We've spent decades building systems that can answer:
Who is allowed?
Far fewer systems can answer:
Who is sufficiently qualified?
Almost none can answer:
Who consistently demonstrates the best judgment?
And almost none can explain:
How should qualification and talent be represented without simply collapsing them into authority?
That feels like a much harder problem than zero-trust.
Should autonomous systems distinguish between being authorized, capable, qualified, talented, and admissible? If so, what evidence should establish qualification and talent without turning either into authority?
14
billyflynt retweeted
Ontology Pipeline — Framework for Knowledge Engineering and Building Knowledge Infrastructures: link.amazon/B06B2xJy5
Amazon description: “One of the biggest shifts happening in our industry is that enterprise data management is expanding into enterprise knowledge management. AI is accelerating that transition because it depends on more than well-managed data. It depends upon context, shared meaning, trusted relationships, and the ability to organize the vast stores of unstructured knowledge that exist across every large enterprise. As AI becomes the primary interface to enterprise information, knowledge management will become the foundation that unlocks trustworthy AI at scale.”
A Skill Is Not a Capability
While developing the LINTEL architecture, this keeps surfacing:
A skill is not necessarily an executable capability.
Many agent skills are instructions. They tell an agent how to perform a task.
But instructions and executable capability are not the same thing.
An agent may be instructed to retrieve, validate a repository, enforce naming rules, inspect archives, or verify artifacts.
The question is:
Are we giving the agent a procedure to interpret, or a governed capability it can invoke?
In the instruction-driven model, the agent repeatedly reconstructs behavior from prose:
Recurring task → Instructions → Agent interpretation → Execution
That works, but it can introduce avoidable variability:
• Different interpretations of the same requirements
• Inconsistent handling of edge conditions
• Repeated reasoning about mechanically decidable operations
• Difficulty demonstrating reproducibility
• Blurred boundaries between advice, authority, and execution
At some point, continually refining instructions stops producing meaningful gains.
We're asking the agent to recreate behavior that should already be implemented.
A capability-first approach looks different:
Recurring work → Governed capability contract → Executable realization → Behavioral verification → Agent-facing skill
In this model:
• The capability contract defines boundaries, invariants, authority limits, and expected outcomes.
• The executable realization performs the work.
• The skill exposes the capability to an agent.
• Behavioral verification provides evidence that the implementation satisfies its contract.
The implementation is replaceable.
A capability might be realized through C++, Python, or another runtime.
What matters is that the contract remains stable.
Some activities are mechanically decidable:
• Does a SHA-256 value match?
• Does a JSON object violate a schema?
• Does a path violate a defined policy?
These are candidates for deterministic execution.
Other activities require judgment and authority:
• Should a requirement be accepted?
• Are two specifications genuinely equivalent?
• Does a proposed change merit admission?
Those decisions belong at explicit governance boundaries, not hidden inside automation.
Not every skill needs to become executable machinery. Procedural skills remain useful, especially where judgment is required.
But when recurring work can be mechanically specified and verified, why repeatedly ask an agent to reconstruct it?
The result is a useful separation of concerns:
Use models where interpretation and judgment are required.
Use deterministic machinery where behavior can be specified and verified.
Use governed boundaries where authority and state change matter.
As agent ecosystems mature, instruction-centric systems may increasingly give way to capability-centric systems.
A skill tells an agent how to access a capability. The capability is what actually does the work.
PRO TOP
Do not create Skills with markdown files, you should be creating Skills with deterministic scripts
1
33
This company called @OsmanticAI seems to be cooking 👀












